How to make a Java thread wait for another thread s output

Question

I m making a Java application with an application-logic-thread and a database-access-thread  Both of them persist for the entire lifetime of the application and both need to be running at the same time  one talks to the server  one talks to the user  when the app is fully started  I need both of them to work    However  on startup  I need to make sure that initially the app thread waits until the db thread is ready  currently determined by polling a custom method dbthread isReady     I wouldn t mind if app thread blocks until the db thread was ready   Thread join   doesn t look like a solution - the db thread only exits at app shutdown   while   dbthread isReady       kind of works  but the empty loop consumes a lot of processor cycles   Any other ideas  Thanks

User · Answer

If you want something quick and dirty  you can just add a Thread sleep   call within your while loop   If the database library is something you can t change  then there is really no other easy solution   Polling the database until is ready with a wait period won t kill the performance   while   dbthread isReady        Thread sleep 250       Hardly something that you could call elegant code  but gets the work done   In case you can modify the database code  then using a mutex as proposed in other answers is better

User · Answer

A lot of correct answers but without a simple example   Here is an easy and simple way how to use CountDownLatch     inside your currentThread   lets call it Thread Main   1 final CountDownLatch latch   new CountDownLatch 1      2    launch thread 2 new Thread new Runnable          Override     public void run               4           do your logic here in thread 2            then release the lock           5         latch countDown             start     try         3 this method will block the thread of latch untill its released later from thread 2     latch await      catch  InterruptedException e        e printStackTrace         6    You reach here after  latch countDown   is called from thread 2

User · Answer

Since    join   has been ruled out  you have already using CountDownLatch and Future get   is already proposed by other experts    You can consider other alternatives    invokeAll from ExecutorService  invokeAll Collection lt   extends Callable lt T gt  gt  tasks       Executes the given tasks  returning a list of Futures holding their status and results when all complete   ForkJoinPool or newWorkStealingPool from Executors   since Java 8 release       Creates a work-stealing thread pool using all available processors as its target parallelism level

User · Answer

Since    join   has been ruled out  you have already using CountDownLatch and Future get   is already proposed by other experts    You can consider other alternatives    invokeAll from ExecutorService  invokeAll Collection lt   extends Callable lt T gt  gt  tasks       Executes the given tasks  returning a list of Futures holding their status and results when all complete   ForkJoinPool or newWorkStealingPool from Executors   since Java 8 release       Creates a work-stealing thread pool using all available processors as its target parallelism level

User · Answer

You could do it using an Exchanger object shared between the two threads   private Exchanger lt String gt  myDataExchanger   new Exchanger lt String gt         Wait for thread s output String data  try     data   myDataExchanger exchange        catch  InterruptedException e1         Handle Exceptions     And in the second thread   try       myDataExchanger exchange data    catch  InterruptedException e         As others have said  do not take this light-hearted and just copy-paste code  Do some reading first

User · Answer

Use a CountDownLatch with a counter of 1   CountDownLatch latch   new CountDownLatch 1     Now in the app thread do-  latch await      In the db thread  after you are done  do -   latch countDown

User · Answer

This idea can apply   If you use CountdownLatches or Semaphores works perfect but if u are looking for the easiest answer for an interview i think this can apply

User · Answer

This applies to all languages   You want to have an event listener model   You create a listener to wait for a particular event   The event would be created  or signaled  in your worker thread   This will block the thread until the signal is received instead of constantly polling to see if a condition is met  like the solution you currently have   Your situation is one of the most common causes for deadlocks- make sure you signal the other thread regardless of errors that may have occurred   Example- if your application throws an exception- and never calls the method to signal the other that things have completed   This will make it so the other thread never  wakes up    I suggest that you look into the concepts of using events and event handlers to better understand this paradigm before implementing your case   Alternatively you can use a blocking function call using a mutex- which will cause the thread to wait for the resource to be free   To do this you need good thread synchronization- such as    Thread-A Locks lock-a Run thread-B Thread-B waits for lock-a Thread-A unlocks lock-a  causing Thread-B to continue  Thread-A waits for lock-b  Thread-B completes and unlocks lock-b

User · Answer

This applies to all languages   You want to have an event listener model   You create a listener to wait for a particular event   The event would be created  or signaled  in your worker thread   This will block the thread until the signal is received instead of constantly polling to see if a condition is met  like the solution you currently have   Your situation is one of the most common causes for deadlocks- make sure you signal the other thread regardless of errors that may have occurred   Example- if your application throws an exception- and never calls the method to signal the other that things have completed   This will make it so the other thread never  wakes up    I suggest that you look into the concepts of using events and event handlers to better understand this paradigm before implementing your case   Alternatively you can use a blocking function call using a mutex- which will cause the thread to wait for the resource to be free   To do this you need good thread synchronization- such as    Thread-A Locks lock-a Run thread-B Thread-B waits for lock-a Thread-A unlocks lock-a  causing Thread-B to continue  Thread-A waits for lock-b  Thread-B completes and unlocks lock-b

User · Answer

You could do it using an Exchanger object shared between the two threads   private Exchanger lt String gt  myDataExchanger   new Exchanger lt String gt         Wait for thread s output String data  try     data   myDataExchanger exchange        catch  InterruptedException e1         Handle Exceptions     And in the second thread   try       myDataExchanger exchange data    catch  InterruptedException e         As others have said  do not take this light-hearted and just copy-paste code  Do some reading first

User · Answer

If you want something quick and dirty  you can just add a Thread sleep   call within your while loop   If the database library is something you can t change  then there is really no other easy solution   Polling the database until is ready with a wait period won t kill the performance   while   dbthread isReady        Thread sleep 250       Hardly something that you could call elegant code  but gets the work done   In case you can modify the database code  then using a mutex as proposed in other answers is better

User · Answer

The Future interface from the java lang concurrent package is designed to provide access to results calculated in another thread   Take a look at FutureTask and ExecutorService for a ready-made way of doing this kind of thing   I d strongly recommend reading Java Concurrency In Practice to anyone interested in concurrency and multithreading  It obviously concentrates on Java  but there is plenty of meat for anybody working in other languages too

User · Answer

I would really recommend that you go through a tutorial like Sun s Java Concurrency before you commence in the magical world of multithreading   There are also a number of good books out  google for  Concurrent Programming in Java    Java Concurrency in Practice    To get to your answer   In your code that must wait for the dbThread  you must have something like this     do some work synchronized objectYouNeedToLockOn       while   dbThread isReady             objectYouNeedToLockOn wait              continue with work after dbThread is ready   In your dbThread s method  you would need to do something like this     do db work synchronized objectYouNeedToLockOn         set ready flag to true  so isReady returns true      ready   true      objectYouNeedToLockOn notifyAll        end thread run method here   The objectYouNeedToLockOn I m using in these examples is preferably the object that you need to manipulate concurrently from  each thread  or you could create a separate Object for that purpose  I would not recommend making the methods themselves synchronized    private final Object lock   new Object      now use lock in your synchronized blocks   To further your understanding  There are other  sometimes better  ways to do the above  e g  with CountdownLatches  etc  Since Java 5 there are a lot of nifty concurrency classes in the java util concurrent package and sub-packages  You really need to find material online to get to know concurrency  or get a good book

User · Answer

I would really recommend that you go through a tutorial like Sun s Java Concurrency before you commence in the magical world of multithreading   There are also a number of good books out  google for  Concurrent Programming in Java    Java Concurrency in Practice    To get to your answer   In your code that must wait for the dbThread  you must have something like this     do some work synchronized objectYouNeedToLockOn       while   dbThread isReady             objectYouNeedToLockOn wait              continue with work after dbThread is ready   In your dbThread s method  you would need to do something like this     do db work synchronized objectYouNeedToLockOn         set ready flag to true  so isReady returns true      ready   true      objectYouNeedToLockOn notifyAll        end thread run method here   The objectYouNeedToLockOn I m using in these examples is preferably the object that you need to manipulate concurrently from  each thread  or you could create a separate Object for that purpose  I would not recommend making the methods themselves synchronized    private final Object lock   new Object      now use lock in your synchronized blocks   To further your understanding  There are other  sometimes better  ways to do the above  e g  with CountdownLatches  etc  Since Java 5 there are a lot of nifty concurrency classes in the java util concurrent package and sub-packages  You really need to find material online to get to know concurrency  or get a good book

User · Answer

The Future interface from the java lang concurrent package is designed to provide access to results calculated in another thread   Take a look at FutureTask and ExecutorService for a ready-made way of doing this kind of thing   I d strongly recommend reading Java Concurrency In Practice to anyone interested in concurrency and multithreading  It obviously concentrates on Java  but there is plenty of meat for anybody working in other languages too

User · Answer

Use a CountDownLatch with a counter of 1   CountDownLatch latch   new CountDownLatch 1     Now in the app thread do-  latch await      In the db thread  after you are done  do -   latch countDown

User · Answer

I would really recommend that you go through a tutorial like Sun s Java Concurrency before you commence in the magical world of multithreading   There are also a number of good books out  google for  Concurrent Programming in Java    Java Concurrency in Practice    To get to your answer   In your code that must wait for the dbThread  you must have something like this     do some work synchronized objectYouNeedToLockOn       while   dbThread isReady             objectYouNeedToLockOn wait              continue with work after dbThread is ready   In your dbThread s method  you would need to do something like this     do db work synchronized objectYouNeedToLockOn         set ready flag to true  so isReady returns true      ready   true      objectYouNeedToLockOn notifyAll        end thread run method here   The objectYouNeedToLockOn I m using in these examples is preferably the object that you need to manipulate concurrently from  each thread  or you could create a separate Object for that purpose  I would not recommend making the methods themselves synchronized    private final Object lock   new Object      now use lock in your synchronized blocks   To further your understanding  There are other  sometimes better  ways to do the above  e g  with CountdownLatches  etc  Since Java 5 there are a lot of nifty concurrency classes in the java util concurrent package and sub-packages  You really need to find material online to get to know concurrency  or get a good book

User · Answer

The Future interface from the java lang concurrent package is designed to provide access to results calculated in another thread   Take a look at FutureTask and ExecutorService for a ready-made way of doing this kind of thing   I d strongly recommend reading Java Concurrency In Practice to anyone interested in concurrency and multithreading  It obviously concentrates on Java  but there is plenty of meat for anybody working in other languages too

User · Answer

Try CountDownLatch class out of the java util concurrent package  which provides higher level synchronization mechanisms  that are far less error prone than any of the low level stuff

User · Answer

A lot of correct answers but without a simple example   Here is an easy and simple way how to use CountDownLatch     inside your currentThread   lets call it Thread Main   1 final CountDownLatch latch   new CountDownLatch 1      2    launch thread 2 new Thread new Runnable          Override     public void run               4           do your logic here in thread 2            then release the lock           5         latch countDown             start     try         3 this method will block the thread of latch untill its released later from thread 2     latch await      catch  InterruptedException e        e printStackTrace         6    You reach here after  latch countDown   is called from thread 2

User · Answer

Requirement      To wait execution of next thread until previous finished  Next thread must not start until previous thread stops  irrespective of time consumption  It must be simple and easy to use    Answer      See java util concurrent Future get   doc  future get   Waits if necessary for the computation to complete  and  then    retrieves its result   Job Done   See example below import java util concurrent Callable  import java util concurrent ExecutionException  import java util concurrent ExecutorService  import java util concurrent Executors   import org junit Test   public class ThreadTest        public void print String m            System out println m              public class One implements Callable lt Integer gt             public Integer call   throws Exception               print  quot One    quot                Thread sleep 6000               print  quot One   quot                return 100                       public class Two implements Callable lt String gt             public String call   throws Exception               print  quot Two    quot                Thread sleep 1000               print  quot Two   quot                return  quot Done quot                        public class Three implements Callable lt Boolean gt             public Boolean call   throws Exception               print  quot Three    quot                Thread sleep 2000               print  quot Three   quot                return true                                   See java util concurrent Future get   doc              lt p gt              Waits if necessary for the computation to complete  and then             retrieves its result               Test     public void poolRun   throws InterruptedException  ExecutionException           int n   3             Build a fixed number of thread pool         ExecutorService pool   Executors newFixedThreadPool n              Wait until One finishes it s task          pool submit new One    get               Wait until Two finishes it s task          pool submit new Two    get               Wait until Three finishes it s task          pool submit new Three    get            pool shutdown             Output of this program    One    One   Two    Two   Three    Three    You can see that  takes 6sec before finishing its task which is greater than other thread  So Future get   waits until the task is done  If you don t use future get   it doesn t wait to finish and executes based time consumption  Good Luck with Java concurrency

User · Answer

The Future interface from the java lang concurrent package is designed to provide access to results calculated in another thread   Take a look at FutureTask and ExecutorService for a ready-made way of doing this kind of thing   I d strongly recommend reading Java Concurrency In Practice to anyone interested in concurrency and multithreading  It obviously concentrates on Java  but there is plenty of meat for anybody working in other languages too

User · Answer

Try CountDownLatch class out of the java util concurrent package  which provides higher level synchronization mechanisms  that are far less error prone than any of the low level stuff

User · Answer

Try CountDownLatch class out of the java util concurrent package  which provides higher level synchronization mechanisms  that are far less error prone than any of the low level stuff

User · Answer

You could do it using an Exchanger object shared between the two threads   private Exchanger lt String gt  myDataExchanger   new Exchanger lt String gt         Wait for thread s output String data  try     data   myDataExchanger exchange        catch  InterruptedException e1         Handle Exceptions     And in the second thread   try       myDataExchanger exchange data    catch  InterruptedException e         As others have said  do not take this light-hearted and just copy-paste code  Do some reading first

User · Answer

You could read from a blocking queue in one thread and write to it in another thread

User · Answer

This applies to all languages   You want to have an event listener model   You create a listener to wait for a particular event   The event would be created  or signaled  in your worker thread   This will block the thread until the signal is received instead of constantly polling to see if a condition is met  like the solution you currently have   Your situation is one of the most common causes for deadlocks- make sure you signal the other thread regardless of errors that may have occurred   Example- if your application throws an exception- and never calls the method to signal the other that things have completed   This will make it so the other thread never  wakes up    I suggest that you look into the concepts of using events and event handlers to better understand this paradigm before implementing your case   Alternatively you can use a blocking function call using a mutex- which will cause the thread to wait for the resource to be free   To do this you need good thread synchronization- such as    Thread-A Locks lock-a Run thread-B Thread-B waits for lock-a Thread-A unlocks lock-a  causing Thread-B to continue  Thread-A waits for lock-b  Thread-B completes and unlocks lock-b

User · Answer

Try CountDownLatch class out of the java util concurrent package  which provides higher level synchronization mechanisms  that are far less error prone than any of the low level stuff

User · Answer

Use a CountDownLatch with a counter of 1   CountDownLatch latch   new CountDownLatch 1     Now in the app thread do-  latch await      In the db thread  after you are done  do -   latch countDown

User · Answer

If you want something quick and dirty  you can just add a Thread sleep   call within your while loop   If the database library is something you can t change  then there is really no other easy solution   Polling the database until is ready with a wait period won t kill the performance   while   dbthread isReady        Thread sleep 250       Hardly something that you could call elegant code  but gets the work done   In case you can modify the database code  then using a mutex as proposed in other answers is better

User · Answer

Use a CountDownLatch with a counter of 1   CountDownLatch latch   new CountDownLatch 1     Now in the app thread do-  latch await      In the db thread  after you are done  do -   latch countDown

User · Answer

I would really recommend that you go through a tutorial like Sun s Java Concurrency before you commence in the magical world of multithreading   There are also a number of good books out  google for  Concurrent Programming in Java    Java Concurrency in Practice    To get to your answer   In your code that must wait for the dbThread  you must have something like this     do some work synchronized objectYouNeedToLockOn       while   dbThread isReady             objectYouNeedToLockOn wait              continue with work after dbThread is ready   In your dbThread s method  you would need to do something like this     do db work synchronized objectYouNeedToLockOn         set ready flag to true  so isReady returns true      ready   true      objectYouNeedToLockOn notifyAll        end thread run method here   The objectYouNeedToLockOn I m using in these examples is preferably the object that you need to manipulate concurrently from  each thread  or you could create a separate Object for that purpose  I would not recommend making the methods themselves synchronized    private final Object lock   new Object      now use lock in your synchronized blocks   To further your understanding  There are other  sometimes better  ways to do the above  e g  with CountdownLatches  etc  Since Java 5 there are a lot of nifty concurrency classes in the java util concurrent package and sub-packages  You really need to find material online to get to know concurrency  or get a good book

User · Answer

This applies to all languages   You want to have an event listener model   You create a listener to wait for a particular event   The event would be created  or signaled  in your worker thread   This will block the thread until the signal is received instead of constantly polling to see if a condition is met  like the solution you currently have   Your situation is one of the most common causes for deadlocks- make sure you signal the other thread regardless of errors that may have occurred   Example- if your application throws an exception- and never calls the method to signal the other that things have completed   This will make it so the other thread never  wakes up    I suggest that you look into the concepts of using events and event handlers to better understand this paradigm before implementing your case   Alternatively you can use a blocking function call using a mutex- which will cause the thread to wait for the resource to be free   To do this you need good thread synchronization- such as    Thread-A Locks lock-a Run thread-B Thread-B waits for lock-a Thread-A unlocks lock-a  causing Thread-B to continue  Thread-A waits for lock-b  Thread-B completes and unlocks lock-b

User · Answer

Requirement      To wait execution of next thread until previous finished  Next thread must not start until previous thread stops  irrespective of time consumption  It must be simple and easy to use    Answer      See java util concurrent Future get   doc  future get   Waits if necessary for the computation to complete  and  then    retrieves its result   Job Done   See example below import java util concurrent Callable  import java util concurrent ExecutionException  import java util concurrent ExecutorService  import java util concurrent Executors   import org junit Test   public class ThreadTest        public void print String m            System out println m              public class One implements Callable lt Integer gt             public Integer call   throws Exception               print  quot One    quot                Thread sleep 6000               print  quot One   quot                return 100                       public class Two implements Callable lt String gt             public String call   throws Exception               print  quot Two    quot                Thread sleep 1000               print  quot Two   quot                return  quot Done quot                        public class Three implements Callable lt Boolean gt             public Boolean call   throws Exception               print  quot Three    quot                Thread sleep 2000               print  quot Three   quot                return true                                   See java util concurrent Future get   doc              lt p gt              Waits if necessary for the computation to complete  and then             retrieves its result               Test     public void poolRun   throws InterruptedException  ExecutionException           int n   3             Build a fixed number of thread pool         ExecutorService pool   Executors newFixedThreadPool n              Wait until One finishes it s task          pool submit new One    get               Wait until Two finishes it s task          pool submit new Two    get               Wait until Three finishes it s task          pool submit new Three    get            pool shutdown             Output of this program    One    One   Two    Two   Three    Three    You can see that  takes 6sec before finishing its task which is greater than other thread  So Future get   waits until the task is done  If you don t use future get   it doesn t wait to finish and executes based time consumption  Good Luck with Java concurrency

User · Answer

You could do it using an Exchanger object shared between the two threads   private Exchanger lt String gt  myDataExchanger   new Exchanger lt String gt         Wait for thread s output String data  try     data   myDataExchanger exchange        catch  InterruptedException e1         Handle Exceptions     And in the second thread   try       myDataExchanger exchange data    catch  InterruptedException e         As others have said  do not take this light-hearted and just copy-paste code  Do some reading first

User · Answer

public class ThreadEvent        private final Object lock   new Object         public void signal             synchronized  lock                lock notify                         public void await   throws InterruptedException           synchronized  lock                lock wait                        Use this class like this then    Create a ThreadEvent   ThreadEvent resultsReady   new ThreadEvent      In the method this is waiting for results   resultsReady await      And in the method that is creating the results after all the results have been created   resultsReady signal      EDIT    Sorry for editing this post  but this code has a very bad race condition and I don t have enough reputation to comment   You can only use this if you are 100  sure that signal   is called after await    This is the one big reason why you cannot use Java object like e g  Windows Events   The if the code runs in this order   Thread 1  resultsReady signal    Thread 2  resultsReady await      then thread 2 will wait forever  This is because Object notify   only wakes up one of the currently running threads  A thread waiting later is not awoken  This is very different from how I expect events to work  where an event is signalled until a  waited for or b  explicitly reset   Note  Most of the time  you should use notifyAll    but this is not relevant to the  wait forever  problem above

User · Answer

public class ThreadEvent        private final Object lock   new Object         public void signal             synchronized  lock                lock notify                         public void await   throws InterruptedException           synchronized  lock                lock wait                        Use this class like this then    Create a ThreadEvent   ThreadEvent resultsReady   new ThreadEvent      In the method this is waiting for results   resultsReady await      And in the method that is creating the results after all the results have been created   resultsReady signal      EDIT    Sorry for editing this post  but this code has a very bad race condition and I don t have enough reputation to comment   You can only use this if you are 100  sure that signal   is called after await    This is the one big reason why you cannot use Java object like e g  Windows Events   The if the code runs in this order   Thread 1  resultsReady signal    Thread 2  resultsReady await      then thread 2 will wait forever  This is because Object notify   only wakes up one of the currently running threads  A thread waiting later is not awoken  This is very different from how I expect events to work  where an event is signalled until a  waited for or b  explicitly reset   Note  Most of the time  you should use notifyAll    but this is not relevant to the  wait forever  problem above

User · Answer

This idea can apply   If you use CountdownLatches or Semaphores works perfect but if u are looking for the easiest answer for an interview i think this can apply

User · Answer

If you want something quick and dirty  you can just add a Thread sleep   call within your while loop   If the database library is something you can t change  then there is really no other easy solution   Polling the database until is ready with a wait period won t kill the performance   while   dbthread isReady        Thread sleep 250       Hardly something that you could call elegant code  but gets the work done   In case you can modify the database code  then using a mutex as proposed in other answers is better

User · Answer

You could read from a blocking queue in one thread and write to it in another thread

[java] How to make a Java thread wait for another thread's output?

Examples related to java

Examples related to multithreading