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
", 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
", 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方法中。
本文完
参考：