简谈Java的join()方法

join()是Thread类的一个方法。根据jdk文档的定义：

public final void join()throws InterruptedException: Waits for this thread to die.

join()方法的作用，是等待这个线程结束；但显然，这样的定义并不清晰。个人认为"Java 7 Concurrency Cookbook"的定义较为清晰：

 

join() method suspends the execution of the calling thread until the object called finishes its execution.

 

也就是说，t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；通常用于在main()主线程内，等待其它线程完成再结束main()主线程。例如：

 1 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 block

30         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 block

32         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 block

68         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方法中。

 

本文完

 

参考：

http://uule.iteye.com/blog/1101994

 

Java 7 Concurency Cookbook