I used to work on an app with long running threads. We do this at shutdown, BlockingQueue<Runnable> queue = threadPool.getQueue(); List<Runnable> list = new ArrayList<Runnable>(); int tasks = queue.drainTo(list); The list is saved to a file. On startup, the list is added back to the pool so we don’t lose any jobs.
Functionally, the two approaches are more or less the same: you submit your tasks for execution; you don’t wait for the result. Technically, however, there are some subtle differences: In the second approach, you didn’t specify an executor, so it will use the common ForkJoinPool. You would have to pass an executor as second argument … Read more
The issue you have is that the scheduler keeps a live thread around after you have cancelled the beep task. If there is a live non-daemon thread, the JVM stays alive. The reason that it keeps this thread around is that you have told it to do so in this line: private final ScheduledExecutorService scheduler … Read more
This really is an ideal candidate for a Phaser. Java 7 is coming out with this new class. Its a flexible CountdonwLatch/CyclicBarrier. You can get a stable version at JSR 166 Interest Site. The way it is a more flexible CountdownLatch/CyclicBarrier is because it is able to not only support an unknown number of parties … Read more
You shouldn’t use executor like this if you want to wait for tasks to finish. What if you don’t want/can’t shutdown your thread pool executor? This is a more recommended way: ExecutorService exec = Executors.newFixedThreadPool(3); Collection<Future<?>> tasks = new LinkedList<Future<?>>(); Future<T> future = exec.submit(A); tasks.add(future); future = exec.submit(B); tasks.add(future); future = exec.submit(C); tasks.add(future); // wait … Read more
Executors.newCachedThreadPool() uses Executors.defaultThreadFactory() for its ThreadFactory. defaultThreadFactory‘s javadocs say that “each new thread is created as a non-daemon thread” (emphasis added). So, the threads created for the newCachedThreadPool are non-daemon. That means that they’ll prevent the JVM from exiting naturally (by “naturally” I mean that you can still call System.exit(1) or kill the program to … Read more
You can pass your own ThreadFactory to ScheduledThreadPoolExecutor. Your ThreadFactory will create thread and can give it any name you want. Your ThreadFactory can also reuse Executors.defaultThreadFactory(), and only change the name before returning the thread.
I’m currently doing it somewhat like this: someExecutor.execute(new Runnable() { @Override public void run() { final String orgName = Thread.currentThread().getName(); Thread.currentThread().setName(orgName + ” – My custom name here”); try { myAction(); } finally { Thread.currentThread().setName(orgName); } } });
I write own Executor that warrants task ordering for tasks with same key. It uses map of queues for order tasks with same key. Each keyed task execute next task with the same key. This solution don’t handle RejectedExecutionException or other exceptions from delegated Executor! So delegated Executor should be “unlimited”. import java.util.HashMap; import java.util.LinkedList; … Read more
There isn’t a clean way to check if all Runnables are done if you use ExecutorService.execute(Runnable). Unless you build a mechanism to do so in the Runnable itself (which is sloppy in my opinion). Instead: Use ExecutorService.submit(Runnable). This method will return a Future<?> which is a handle to the result of a Runnable. Using Futures … Read more