ExecutorService how to wait for all tasks to finish

Question

What is the simplest way to to wait for all tasks of ExecutorService to finish  My task is primarily computational  so I just want to run a large number of jobs - one on each core   Right now my setup looks like this    ExecutorService es   Executors newFixedThreadPool 2   for  DataTable singleTable   uniquePhrases           es execute new ComputeDTask singleTable      try      es wait       catch  InterruptedException e       e printStackTrace        ComputeDTask implements runnable   This appears to execute the tasks correctly  but the code crashes on wait   with IllegalMonitorStateException   This is odd  because I played around with some toy examples and it appeared to work     uniquePhrases contains several tens of thousands of elements   Should I be using another method   I am looking for something as simple as possible

User · Answer

I will just wait for the executor to terminate with a specified timeout that you think  it is suitable for the tasks to complete    try                do stuff here           exe execute thread         finally           exe shutdown              boolean result   exe awaitTermination 4  TimeUnit HOURS       if   result                 LOGGER error  It took more than 4 hour for the executor to stop  this shouldn t be the normal behaviour

User · Answer

Submit your tasks into the Runner and then wait calling the method waitTillDone   like this   Runner runner   Runner runner 2    for  DataTable singleTable   uniquePhrases         runner run new ComputeDTask singleTable          blocks until all tasks are finished  or failed  runner waitTillDone     runner shutdown      To use it add this gradle maven dependency   com github matejtymes javafixes 1 0   For more details look here  https   github com MatejTymes JavaFixes or here  http   matejtymes blogspot com 2016 04 executor-that-notifies-you-when-task html

User · Answer

If you want to wait for the executor service to finish executing  call shutdown   and then  awaitTermination units  unitType   e g  awaitTermination 1  MINUTE   The ExecutorService does not block on it s own monitor  so you can t use wait etc

User · Answer

You could wait jobs to finish on a certain interval   int maxSecondsPerComputeDTask   20  try       while   es awaitTermination uniquePhrases size     maxSecondsPerComputeDTask  TimeUnit SECONDS                consider giving up with a  break  statement under certain conditions         catch  InterruptedException e        throw new RuntimeException e           Or you could use ExecutorService submit Runnable  and collect the Future objects that it returns and call get   on each in turn to wait for them to finish   ExecutorService es   Executors newFixedThreadPool 2   Collection lt Future lt   gt  gt  futures   new LinkedList lt  lt Future lt   gt  gt     for  DataTable singleTable   uniquePhrases        futures add es submit new ComputeDTask singleTable       for  Future lt   gt  future   futures       try          future get         catch  InterruptedException e           throw new RuntimeException e        catch  ExecutionException e           throw new RuntimeException e            InterruptedException is extremely important to handle properly   It is what lets you or the users of your library terminate a long process safely

User · Answer

The simplest approach is to use ExecutorService invokeAll   which does what you want in a one-liner   In your parlance  you ll need to modify or wrap ComputeDTask to implement Callable lt  gt   which can give you quite a bit more flexibility   Probably in your app there is a meaningful implementation of Callable call    but here s a way to wrap it if not using Executors callable     ExecutorService es   Executors newFixedThreadPool 2   List lt Callable lt Object gt  gt  todo   new ArrayList lt Callable lt Object gt  gt  singleTable size      for  DataTable singleTable  uniquePhrases         todo add Executors callable new ComputeDTask singleTable         List lt Future lt Object gt  gt  answers   es invokeAll todo     As others have pointed out  you could use the timeout version of invokeAll   if appropriate   In this example  answers is going to contain a bunch of Futures which will return nulls  see definition of Executors callable     Probably what you want to do is a slight refactoring so you can get a useful answer back  or a reference to the underlying ComputeDTask  but I can t tell from your example   If it isn t clear  note that invokeAll   will not return until all the tasks are completed     i e   all the Futures in your answers collection will report  isDone   if asked    This avoids all the manual shutdown  awaitTermination  etc    and allows you to reuse this ExecutorService neatly for multiple cycles  if desired   There are a few related questions on SO    How to wait for all threads to finish Return values from java threads invokeAll   not willing to accept a Collection lt Callable lt t gt  gt  Do I need to synchronize    None of these are strictly on-point for your question  but they do provide a bit of color about how folks think Executor ExecutorService ought to be used

User · Answer

Just use   latch   new CountDownLatch noThreads    In each thread   latch countDown      and as barrier  latch await

User · Answer

Sounds like you need ForkJoinPool and use the global pool to execute tasks   public static void main String   args           the default  commonPool  should be sufficient for many cases      ForkJoinPool pool   ForkJoinPool commonPool            The root of your task that may spawn other tasks          Make sure it submits the additional tasks to the same executor that it is in      Runnable rootTask   new YourTask pool        pool execute rootTask       pool awaitQuiescence              that s it      The beauty is in pool awaitQuiescence where the method will block utilize the caller s thread to execute its tasks and then return when it is really empty

User · Answer

If waiting for all tasks in the ExecutorService to finish isn t precisely your goal  but rather waiting until a specific batch of tasks has completed  you can use a CompletionService  mdash  specifically  an ExecutorCompletionService   The idea is to create an ExecutorCompletionService wrapping your Executor  submit some known number of tasks through the CompletionService  then draw that same number of results from the completion queue using either take    which blocks  or poll    which does not   Once you ve drawn all the expected results corresponding to the tasks you submitted  you know they re all done   Let me state this one more time  because it s not obvious from the interface  You must know how many things you put into the CompletionService in order to know how many things to try to draw out  This matters especially with the take   method  call it one time too many and it will block your calling thread until some other thread submits another job to the same CompletionService   There are some examples showing how to use CompletionService in the book Java Concurrency in Practice

User · Answer

Root cause for IllegalMonitorStateException      Thrown to indicate that a thread has attempted to wait on an object s monitor or to notify other threads waiting on an object s monitor without owning the specified monitor    From your code  you have just called wait   on ExecutorService without owning the lock   Below code will fix IllegalMonitorStateException  try        synchronized es           es wait       Add some condition before you call wait              Follow one of below approaches to wait for completion of all tasks  which have been submitted to ExecutorService     Iterate through all Future tasks from submit on ExecutorService and check the status with blocking call get   on Future object Using invokeAll on ExecutorService  Using CountDownLatch Using ForkJoinPool or newWorkStealingPool of Executors since java 8  Shutdown the pool as recommended in oracle documentation page  void shutdownAndAwaitTermination ExecutorService pool       pool shutdown       Disable new tasks from being submitted    try         Wait a while for existing tasks to terminate    if   pool awaitTermination 60  TimeUnit SECONDS            pool shutdownNow       Cancel currently executing tasks           Wait a while for tasks to respond to being cancelled        if   pool awaitTermination 60  TimeUnit SECONDS          System err println  Pool did not terminate           catch  InterruptedException ie             Re- Cancel if current thread also interrupted      pool shutdownNow            Preserve interrupt status      Thread currentThread   interrupt        If you want to gracefully wait for all tasks for completion when you are using option 5 instead of options 1 to 4  change   if   pool awaitTermination 60  TimeUnit SECONDS       to  a while condition  which checks for every 1 minute

User · Answer

I also have the situation that I have a set of documents to be crawled  I start with an initial  quot seed quot  document which should be processed  that document contains links to other documents which should also be processed  and so on  In my main program  I just want to write something like the following  where Crawler controls a bunch of threads  Crawler c   new Crawler    c schedule seedDocument    c waitUntilCompletion    The same situation would happen if I wanted to navigate a tree  i would pop in the root node  the processor for each node would add children to the queue as necessary  and a bunch of threads would process all the nodes in the tree  until there were no more  I couldn t find anything in the JVM which I thought was a bit surprising  So I wrote a class ThreadPool which one can either use directly or subclass to add methods suitable for the domain  e g  schedule Document   Hope it helps  ThreadPool Javadoc   Maven

User · Answer

A simple alternative to this is to use threads along with join  Refer   Joining Threads

User · Answer

Add all threads in collection and submit it using invokeAll  If you can use invokeAll method of ExecutorService  JVM won   t proceed to next line until all threads are complete   Here there is a good example  invokeAll via ExecutorService

User · Answer

how about this  Object lock   new Object    CountDownLatch cdl   new CountDownLatch threadNum   for  int i   0  i  lt  threadNum  i          executorService execute    - gt             synchronized  lock                cdl countDown                try                   lock wait                  catch  InterruptedException e                    Thread currentThread   interrupt                                      cdl await    synchronized  lock        lock notifyAll       if you do not add new tasks to ExecutorService   this may wait for all current tasks completed

User · Answer

You can use ExecutorService invokeAll method  It will execute all task and wait till all threads finished their task   Here is complete javadoc  You can also user overloaded version of this method to specify the timeout   Here is sample code with ExecutorService invokeAll  public class Test       public static void main String   args  throws InterruptedException  ExecutionException           ExecutorService service   Executors newFixedThreadPool 3           List lt Callable lt String gt  gt  taskList   new ArrayList lt  gt             taskList add new Task1             taskList add new Task2             List lt Future lt String gt  gt  results   service invokeAll taskList           for  Future lt String gt  f   results                System out println f get                         class Task1 implements Callable lt String gt         Override     public String call   throws Exception           try               Thread sleep 2000               return  Task 1 done             catch  Exception e                e printStackTrace                return   error in task1                      class Task2 implements Callable lt String gt         Override     public String call   throws Exception           try               Thread sleep 3000               return  Task 2 done             catch  Exception e                e printStackTrace                return   error in task2

User · Answer

If you want to wait for all tasks to complete  use the shutdown method instead of wait   Then follow it with awaitTermination     Also  you can use Runtime availableProcessors to get the number of hardware threads so you can initialize your threadpool properly

[java] ExecutorService, how to wait for all tasks to finish

Examples related to java

Examples related to multithreading

Examples related to threadpool

Examples related to executorservice