executorservice

The javadoc for ExecutorService sometimes refers to the case when a Thread terminates 'due to failure'. However, it is not clear what kind of failure does this refer to. For instance, the single thread executor documentation says that if this single thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks I would have thought that this situation might happen in case of an Exception, or maybe a RuntimeException , but it does not seem to be the case. Running the following code seems to be giving the same thread

Let's assume we have the following code: List<Future<?>> runningTasks; ExecutorService executor; ... void executeTask(Runnable task){ runningTasks.add(executor.submit(task)); } My questions are: Does runningTasks hold a reference to the task object? How long does it hold it for? Does it still hold it after the task is complete? In order to avoid memory leaks do I have to take care to remove the future that was added to the list? Until when the executor or the Future object holds a reference to it is an implementation detail . Therefore, if your tasks use a lot of memory such that you have to

I am using cached thread pool ExecutorService to run some asynchronous background tasks. I've provided my ThreadFactory that hands out threads to the ExecutorService (whenever it needs them). My understanding of the cached thread pool is that after the thread is sitting idle for 60 seconds it is termniated by the ExecutorService. I want to perform some state cleanup when my thread is about to be terminated. What is the best way to achieve this? The ExecutorService does not readily provide hooks into the thread's lifecycle. I don't want to shutdown my ExecutorService - useful for running tasks

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center . If I create a fixed size thread pool with 10 threads in java using Executor framework: private final ExecutorService pool; pool = Executors.newFixedThreadPool(10); and then try to submit more than 10 tasks (say for an example, 12 tasks); for (int i = 0 ; i < 12 ; i++) { pool.execute(new Handler(myRunnable)); } What will happen to the

I have a rather massive number of threads being created inside a clojure program: (import '(java.util.concurrent Executors)) (def *pool* (Executors/newCachedThreadPool)) (defn do-something [] ; work Thread/sleep 200 ; repeat) (dotimes [i 10000] (.submit *pool* do-something)) It's been a while between JVMs for me and I am basically wondering here if there is any argument against using sleep or yield inside the function that is being executed by the Executor? If I understand correctly, in this case, every one of my workers has it's own thread and therefore there should be no side effects. If the

I have a scenario where I have to poll a remote server checking if a task has completed. Once it has, I make a different call to retrieve the result. I originally figured I should use a SingleThreadScheduledExecutor with scheduleWithFixedDelay for polling: ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); ScheduledFuture future = executor.scheduleWithFixedDelay(() -> poll(jobId), 0, 10, TimeUnit.SECONDS); public void poll(String jobId) { boolean jobDone = remoteServer.isJobDone(jobId); if (jobDone) { retrieveJobResult(jobId); } } But since I can only provide a