Thread类的join()

join() method suspends the execution of the calling thread until the object called finishes its execution. 也就是说，t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；通常用于在main()主线程内，等待其它线程完成再结束main()主线程。

例如：

public class JoinTester01 implements Runnable { 2  3     private String name; 4  5     public JoinTester01(String name) { 6     this.name = name; 7     } 8  9     public void run() {10     System.out.printf("%s begins: %s\n", name, new Date());11     try {12         TimeUnit.SECONDS.sleep(4);13     } catch (InterruptedException e) {14         e.printStackTrace();15     }16     System.out.printf("%s has finished: %s\n", name, new Date());17     }18 19     public static void main(String[] args) {20     Thread thread1 = new Thread(new JoinTester01("One"));21     Thread thread2 = new Thread(new JoinTester01("Two"));22     thread1.start();23     thread2.start();24     25     try {26         thread1.join();27         thread2.join();28     } catch (InterruptedException e) {29         // TODO Auto-generated catch block30         e.printStackTrace();31     }32     33     System.out.println("Main thread is finished");34     }35 36 }

上述代码如果没有join()方法，输出如下：

Main thread is finished
One begins: Wed Aug 28 10:21:36 CST 2013
Two begins: Wed Aug 28 10:21:36 CST 2013
Two has finished: Wed Aug 28 10:21:40 CST 2013
One has finished: Wed Aug 28 10:21:40 CST 2013

可以看出主线程main比其它两个线程先结束。

最后来深入了解一下join()，请看其源码：

 1 /** 2      *  Waits at most <code>millis</code> milliseconds for this thread to   3      * die. A timeout of <code>0</code> means to wait forever.     4      */ 5     //此处A timeout of 0 means to wait forever 字面意思是永远等待，其实是等到t结束后。 6     public final synchronized void join(long millis)    throws InterruptedException { 7         long base = System.currentTimeMillis(); 8         long now = 0; 9 10         if (millis < 0) {11             throw new IllegalArgumentException("timeout value is negative");12         }13         14         if (millis == 0) {15             while (isAlive()) {16                 wait(0);17             }18         } else {19             while (isAlive()) {20                 long delay = millis - now;21                 if (delay <= 0) {22                     break;23                 }24                 wait(delay);25                 now = System.currentTimeMillis() - base;26             }27         }28     }

 可以看出，Join方法实现是通过wait（小提示：Object 提供的方法）。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁。

 1 public class JoinTester02 implements Runnable { 2  3     Thread thread; 4  5     public JoinTester02(Thread thread) { 6     this.thread = thread; 7     } 8  9     public void run() {10     synchronized (thread) {11         System.out.println("getObjectLock");12         try {13         Thread.sleep(9000);14         } catch (InterruptedException ex) {15         ex.printStackTrace();16         }17         System.out.println("ReleaseObjectLock");18     }19     }20 21     public static void main(String[] args) {22     Thread thread = new Thread(new JoinTester01("Three"));23     Thread getLockThread = new Thread(new JoinTester02(thread));24     25     getLockThread.start();26     thread.start();27     28     try {29         thread.join();30     } catch (InterruptedException e) {31         // TODO Auto-generated catch block32         e.printStackTrace();33     }34     System.out.println("Main finished!");35     }36 37 }public class JoinTester02 implements Runnable {38 39     Thread thread;40 41     public JoinTester02(Thread thread) {42     this.thread = thread;43     }44 45     public void run() {46     synchronized (thread) {47         System.out.println("getObjectLock");48         try {49         Thread.sleep(9000);50         } catch (InterruptedException ex) {51         ex.printStackTrace();52         }53         System.out.println("ReleaseObjectLock");54     }55     }56 57     public static void main(String[] args) {58     Thread thread = new Thread(new JoinTester01("Three"));59     Thread getLockThread = new Thread(new JoinTester02(thread));60     61     getLockThread.start();62     thread.start();63     64     try {65         thread.join();66     } catch (InterruptedException e) {67         // TODO Auto-generated catch block68         e.printStackTrace();69     }70     System.out.println("Main finished!");71     }72 73 }

输出如下：

getObjectLock
Three begins: Wed Aug 28 10:42:00 CST 2013
Three has finished: Wed Aug 28 10:42:04 CST 2013
ReleaseObjectLock
Main finished!

getLockThread通过 synchronized  (thread) ，获取线程对象t的锁，并Sleep（9000）后释放，这就意味着，即使main方法t.join(1000)等待一秒钟，它必须等待ThreadTest 线程释放t锁后才能进入wait方法中。