简谈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

posted @ 2013-08-28 10:44 macemers 阅读(...) 评论(...) 编辑 收藏