wait until all threads finish their work in java

Question

I m writing an application that has 5 threads that get some information from web simultaneously and fill 5 different fields in a buffer class  I need to validate buffer data and store it in a database when all threads finished their job  How can I do this  get alerted when all threads finished their work

User · Answer

You can use Threadf join method for this purpose

User · Answer

Store the Thread-objects into some collection  like a List or a Set   then loop through the collection once the threads are started and call join   on the Threads

User · Answer

An executor service can be used to manage multiple threads including status and completion   See http   programmingexamples wikidot com executorservice

User · Answer

You can join to the threads  The join blocks until the thread completes   for  Thread thread   threads        thread join        Note that join throws an InterruptedException  You ll have to decide what to do if that happens  e g  try to cancel the other threads to prevent unnecessary work being done

User · Answer

You do  for  Thread t   new Thread     th1  th2  th3  th4  th5        t join     After this for loop  you can be sure all threads have finished their jobs

User · Answer

I had similar situation   where i had to wait till all child threads complete its execution then only i could get the status result for each of them    hence i needed to wait till all child thread completed  below is my code where i did multi-threading using  public static void main String   args            List lt RunnerPojo gt  testList   ExcelObject getTestStepsList      parallelStream   collect Collectors toList             int threadCount   ConfigFileReader getInstance   readConfig   getParallelThreadCount            System out println  quot Thread count is               quot    threadCount      5          ExecutorService threadExecutor   new DriverScript   threadExecutor testList  threadCount             boolean isProcessCompleted   waitUntilCondition    - gt  threadExecutor isTerminated        Here i used waitUntil condition           if  isProcessCompleted                testList forEach x - gt                    System out println  quot Test Name   quot    x getTestCaseId                     System out println  quot Test Status    quot    x getStatus                     System out println  quot         Test Steps        quot                     x getTestStepsList   forEach y - gt                        System out println  quot Step Name   quot    y getDescription                         System out println  quot Test caseId    quot    y getTestCaseId                         System out println  quot Step Status   quot    y getResult                         System out println  quot  n                         quot                                                   Below method is for distribution of list with parallel proccessing    This method will split my list and run in a parallel process with mutliple threads     private ExecutorService threadExecutor List lt RunnerPojo gt  testList  int threadSize            ExecutorService exec   Executors newFixedThreadPool threadSize           testList forEach tests - gt                exec submit    - gt                    driverScript tests                                       exec shutdown            return exec         This is my wait until method  here you can wait till your condition satisfies within do while loop   in my case i waited for some max timeout   this will keep checking until your threadExecutor isTerminated   is true with polling period of 5 sec      static boolean waitUntilCondition Supplier lt Boolean gt  function            Double timer   0 0          Double maxTimeOut   20 0           boolean isFound          do               isFound   function get                if  isFound                    break                else                   try                       Thread sleep 5000      Sleeping for 5 sec  main thread will sleep for 5 sec                    catch  InterruptedException e                        e printStackTrace                                      timer                    System out println  quot Waiting for condition to be true    waited    quot    timer   5    quot  sec  quot                            while  timer  lt  maxTimeOut   1 0            return isFound

User · Answer

The approach I take is to use an ExecutorService to manage pools of threads   ExecutorService es   Executors newCachedThreadPool    for int i 0 i lt 5 i        es execute new Runnable         your task        es shutdown    boolean finished   es awaitTermination 1  TimeUnit MINUTES      all tasks have finished or the time has been reached

User · Answer

Although not relevant to OP s problem  if you are interested in synchronization  more precisely  a rendez-vous  with exactly one thread  you may use an Exchanger  In my case  I needed to pause the parent thread until the child thread did something  e g  completed its initialization  A CountDownLatch also works well

User · Answer

I created a small helper method to wait for a few Threads to finish    public static void waitForThreadsToFinish Thread    threads            try               for  Thread thread   threads                    thread join                                    catch  InterruptedException e                e printStackTrace

User · Answer

Wait block the Thread Main until some other threads complete their work   As  Ravindra babu said it can be achieved in various ways  but showing with examples    java lang Thread join   Since 1 0  public static void joiningThreads   throws InterruptedException       Thread t1   new Thread  new LatchTask 1  null    T1         Thread t2   new Thread  new LatchTask 7  null    T2         Thread t3   new Thread  new LatchTask 5  null    T3         Thread t4   new Thread  new LatchTask 2  null    T4             Start all the threads     t1 start        t2 start        t3 start        t4 start            Wait till all threads completes     t1 join        t2 join        t3 join        t4 join       java util concurrent CountDownLatch Since 1 5    countDown      Decrements the count of the latch group   await      The await methods block until the current count reaches zero    If you created latchGroupCount   4 then countDown   should be called 4 times to make count 0  So  that await   will release the blocking threads   public static void latchThreads   throws InterruptedException       int latchGroupCount   4      CountDownLatch latch   new CountDownLatch latchGroupCount       Thread t1   new Thread  new LatchTask 1  latch    T1         Thread t2   new Thread  new LatchTask 7  latch    T2         Thread t3   new Thread  new LatchTask 5  latch    T3         Thread t4   new Thread  new LatchTask 2  latch    T4          t1 start        t2 start        t3 start        t4 start           latch countDown         latch await       block until latchGroupCount is 0       Example code of Threaded class LatchTask  To test the approach use joiningThreads    and latchThreads    from main method   class LatchTask extends Thread       CountDownLatch latch      int iterations   10      public LatchTask int iterations  CountDownLatch latch            this iterations   iterations          this latch   latch              Override     public void run             String threadName   Thread currentThread   getName            System out println threadName       Started Task                for  int i   0  i  lt  iterations  i                  System out println threadName           i               MainThread Wait TillWorkerThreadsComplete sleep 1                     System out println threadName       Completed Task               countDown      Decrements the count of the latch group          if latch    null              latch countDown               CyclicBarriers A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other  The barrier is called cyclic because it can be re-used after the waiting threads are released   CyclicBarrier barrier   new CyclicBarrier 3   barrier await      For example refer this Concurrent ParallelNotifyies class       Executer framework  we can use ExecutorService to create a thread pool  and tracks the progress of the asynchronous tasks with Future    submit Runnable   submit Callable  which return Future Object  By using future get   function we can block the main thread till the working threads completes its work  invokeAll      - returns a list of Future objects via which you can obtain the results of the executions of each Callable     Find example of using Interfaces Runnable  Callable with Executor framework      See also   Find out thread is still alive

User · Answer

The existing answers said could join   each thread   But there are several ways to get the thread array   list      Add the Thread into a list on creation  Use ThreadGroup to manage the threads    Following code will use the ThreadGruop approach  It create a group first  then when create each thread specify the group in constructor  later could get the thread array via ThreadGroup enumerate      Code  SyncBlockLearn java  import org testng Assert  import org testng annotations Test          synchronized block - learn         author eric     date Apr 20  2015 1 37 11 PM     public class SyncBlockLearn       private static final int TD COUNT   5     thread count     private static final int ROUND PER THREAD   100     round for each thread      private static final long INC DELAY   10     delay of each increase          sync block test       Test     public void syncBlockTest   throws InterruptedException           Counter ct   new Counter            ThreadGroup tg   new ThreadGroup  runner             for  int i   0  i  lt  TD COUNT  i                  new Thread tg  ct   t-    i  start                       Thread   tArr   new Thread TD COUNT           tg enumerate tArr      get threads              wait all runner to finish          for  Thread t   tArr                t join                       System out printf   nfinal count   d n   ct getCount             Assert assertEquals ct getCount    TD COUNT   ROUND PER THREAD              static class Counter implements Runnable           private final Object lkOn   new Object       the object to lock on          private int count   0            Override         public void run                 System out printf    s  begin n   Thread currentThread   getName                  for  int i   0  i  lt  ROUND PER THREAD  i                      synchronized  lkOn                        System out printf    s    d  inc to   d n   Thread currentThread   getName    i    count                                     try                       Thread sleep INC DELAY      wait a while                    catch  InterruptedException e                        e printStackTrace                                                 System out printf    s  end n   Thread currentThread   getName                        public int getCount                 return count                      The main thread will wait for all threads in the group to finish

User · Answer

Have a look at various solutions     join   API has been introduced in early versions of Java  Some good alternatives are available with this concurrent package since the JDK 1 5 release  ExecutorService invokeAll       Executes the given tasks  returning a list of Futures holding their status and results when everything is completed    Refer to this related SE question for code example   How to use invokeAll   to let all thread pool do their task  CountDownLatch     A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes       A CountDownLatch is initialized with a given count  The await methods block until the current count reaches zero due to invocations of the countDown   method  after which all waiting threads are released and any subsequent invocations of await return immediately  This is a one-shot phenomenon -- the count cannot be reset  If you need a version that resets the count  consider using a CyclicBarrier    Refer to this question for usage of CountDownLatch  How to wait for a thread that spawns it  39 s own thread  ForkJoinPool or     newWorkStealingPool   in Executors  Iterate through all Future objects created after submitting to ExecutorService

User · Answer

Use this in your main thread  while  executor isTerminated     Put this line of code after starting all the threads from executor service  This will only start the main thread after all the threads started by executors are finished  Make sure to call executor shutdown    before the above loop

User · Answer

Another possibility is the CountDownLatch object  which is useful for simple situations   since you know in advance the number of threads  you initialize it with the relevant count  and pass the reference of the object to each thread  Upon completion of its task  each thread calls CountDownLatch countDown   which decrements the internal counter  The main thread  after starting all others  should do the CountDownLatch await   blocking call  It will be released as soon as the internal counter has reached 0   Pay attention that with this object  an InterruptedException can be thrown as well

User · Answer

Apart from Thread join   suggested by others  java 5 introduced the executor framework  There you don t work with Thread objects  Instead  you submit your Callable or Runnable objects to an executor  There s a special executor that is meant to execute multiple tasks and return their results out of order  That s the ExecutorCompletionService   ExecutorCompletionService executor  for            executor submit Executors callable yourRunnable        Then you can repeatedly call take   until there are no more Future lt   gt  objects to return  which means all of them are completed     Another thing that may be relevant  depending on your scenario is CyclicBarrier      A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point  CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other  The barrier is called cyclic because it can be re-used after the waiting threads are released

User · Answer

I had a similar problem and ended up using Java 8 parallelStream   requestList parallelStream   forEach req - gt  makeRequest req      It s super simple and readable  Behind the scenes it is using default JVM   s fork join pool which means that it will wait for all the threads to finish before continuing  For my case it was a neat solution  because it was the only parallelStream in my application  If you have more than one parallelStream running simultaneously  please read the link below   More information about parallel streams here

User · Answer

try this  will work     Thread   threads   new Thread 10      List lt Thread gt  allThreads   new ArrayList lt Thread gt        for Thread thread   threads            if null    thread                  if thread isAlive                          allThreads add thread                                       while  allThreads isEmpty              Iterator lt Thread gt  ite   allThreads iterator             while ite hasNext                    Thread thread   ite next                   if  thread isAlive                         ite remove

[java] wait until all threads finish their work in java

Examples related to java

Examples related to multithreading

Examples related to wait