简谈Java的join（）⽅法
join()是Thread类的⼀个⽅法。根据jdk⽂档的定义：
public final void join()throws : 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()主线程。例如：
1public class JoinTester01 implements Runnable {
2
3private String name;
4
5public JoinTester01(String name) {
6this.name = name;
7 }
8梦见小龙虾
9public void run() {
10 System.out.printf("%s begins: %s\n", name, new Date());
11try {
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
19public 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
25try {
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> milliconds 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结束后。
6public final synchronized void join(long millis) throws InterruptedException {
7long ba = System.currentTimeMillis();
8long now = 0;
10if (millis < 0) {
11throw new IllegalArgumentException("timeout value is negative");
12 }
塞浦路斯旅游13
14if (millis == 0) {
15while (isAlive()) {
16 wait(0);
17 }
18 } el {
19while (isAlive()) {
20long delay = millis - now;
21if (delay <= 0) {
22break;
23 }
24 wait(delay);
25 now = System.currentTimeMillis() - ba;
26 }
27 }
28 }
可以看出，Join⽅法实现是通过wait（⼩提⽰：Object 提供的⽅法）。当main线程调⽤t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁)，调⽤该对象的wait(等待时间)，直到该对象唤醒main线程，⽐如退出后。这就意味着main 线程调⽤t.join时，必须能够拿到线程t对象的锁。
1public class JoinTester02 implements Runnable {
2
3 Thread thread;
4
5public JoinTester02(Thread thread) {
6this.thread = thread;
7 }
8
开阔眼界英语
9public void run() {
10synchronized (thread) {
11 System.out.println("getObjectLock");
12try {
13 Thread.sleep(9000);
14 } catch (InterruptedException ex) {
15 ex.printStackTrace();
16 }
17 System.out.println("ReleaObjectLock");
18 }
19 }
20
21public 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
28try {
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
41public JoinTester02(Thread thread) {
42this.thread = thread;
43 }
44
45public void run() {
46synchronized (thread) {
47 System.out.println("getObjectLock");
48try {
49 Thread.sleep(9000);
50 } catch (InterruptedException ex) {
51 ex.printStackTrace();
52 }
53 System.out.println("ReleaObjectLock");
54 }
56
57public 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
64try {
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
ReleaObjectLock
Main finished!
getLockThread通过 synchronized (thread) ，获取线程对象t的锁，并Sleep（9000）后释放，这就意味着，即使main⽅法t.join(1000)等待⼀秒钟，它必须等待ThreadTest 线程释放t锁后才能进⼊wait⽅法中。
本⽂完
参考：
Java 7 Concurency Cookbook
