Table of Contents
Thread class’s join() method can be used to stop current execution of thread until thread it joins, completes its task. So basically, it waits for the thread on which join method is getting called, to die.For example:
Here when you call t1.join(), main thread will wait for t1 to complete its start before resuming its execution.
|
1 2 3 4 5 6 7 8 |
// Main thread execution Thread t1=new Thread(mr,"Thread 1");t1.start(); // lets waits for t1 to die try { t1.join(); } catch (InterruptedException e) { |
Variants of join methods
There are three variant of join method
public final void join() throws InterruptedException
Thread on which join method is getting called, to die.
public final void join(long millis) throws InterruptedException
This method when called on the thread, it waits for either of following:
- Thread on which join method is getting called, to die.
- Specified milliseconds
public final void join(long millis,int nanos) throws InterruptedException
This method when called on the thread, it waits for either of following:
- Thread on which join method is getting called, to die.
- Specified milliseconds + nano seconds
💡 Did you know?
If the thread, on which join method is called, has been already terminated or has not been started yet, then join method returns immediately.
Java Thread Join example
Let’s take a simple example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package org.arpit.java2blog; public class MyRunnable implements Runnable { public void run() { try { System.out.println(Thread.currentThread().getName() + " Start"); // thread sleeps for 4 secs Thread.sleep(4000); System.out.println(Thread.currentThread().getName() + " end"); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } |
Create ThreadExampleMain.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
package org.arpit.java2blog; public class ThreadExampleMain { public static void main(String args[]) { System.out.println("Main thread execution starts"); MyRunnable mr = new MyRunnable(); Thread t1 = new Thread(mr, "Thread 1"); Thread t2 = new Thread(mr, "Thread 2"); Thread t3 = new Thread(mr, "Thread 3"); t1.start(); // lets waits for t1 to die try { t1.join(); } catch (InterruptedException e) { e.printStackTrace(); } t2.start(); try { // lets waits for 1 sec or t2 to die which ever occurs first t2.join(1000); } catch (InterruptedException e1) { e1.printStackTrace(); } t3.start(); // complete all threads before completing main thread try { t2.join(); t3.join(); } catch (InterruptedException e1) { e1.printStackTrace(); } System.out.println("Main thread execution ends"); } } |
When you run above program, you will get following output.
Thread 1 Start
Thread 1 end
Thread 2 Start
Thread 3 Start
Thread 2 end
Thread 3 end
Main thread execution ends
Lets analysis output now.
- Main thread execution starts.
- Thread 1 starts(Thread 1 start) and as we have put t1.join(), it will wait for t1 to die(Thread 1 end).
- Thread 2 starts(Thread 2 start) and waits for either 1 seconds or die, but as we have put sleep for 4 seconds in run method, it will not die in 1 second. so main thread resumes and Thread 3starts(Thread 3 start)
- As we have put t2.join() and t3.join(). These 2 threads will get completed before exiting main thread, so Thread 2 will end(Thread 2 end ) and then thread 3 will end(Thread 3 end).
- Main thread execution ends.
Java Thread Join and Synchornization
Java thread join method guarantees happens before relationship.
It means if thread t1 calls t2.join(), then all the changes done by t2 are visible to t1.
That’s all about Java Thread Join Example.
