thread.Join把指定的執行緒加入到當前執行緒，可以將兩個交替執行的執行緒合併為順序執行的執行緒。

比如線上程B中呼叫了執行緒A的Join()方法，直到執行緒A執行完畢後，才會繼續執行執行緒B。

t.join();      //呼叫join方法，等待執行緒t執行完畢
t.join(1000);  //等待 t 執行緒，等待時間是1000毫秒。

下面是一段JDK中的程式碼：

    /**
     *  Waits at most <code>millis</code> milliseconds for this thread to  
     * die. A timeout of <code>0</code> means to wait forever.    
     
 
*/
    
    public final synchronized void join(long millis)    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        
        if (millis == 0) {
            
 
while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
 

從程式碼上看，如果執行緒被生成了，但還未被起動，呼叫它的 join() 方法是沒有作用的，將直接繼續向下執行

Join方法實現是通過wait（小提示：Object 提供的方法）。 當main執行緒呼叫t.join時候，main執行緒會獲得執行緒物件t的鎖（wait 意味著拿到該物件的鎖),呼叫該物件的wait(等待時間)，直到該物件喚醒main執行緒 ，比如退出後。這就意味著main 執行緒呼叫t.join時，必須能夠拿到執行緒t物件的鎖。

通過下面一段程式碼解釋：

package ThreadTest;

import static java.lang.Thread.currentThread;
import static java.lang.Thread.sleep;

/**
 * Created with IntelliJ IDEA.
 * User: Blank
 * Date: 14-3-28
 * Time: 下午7:49
 */
public class TestJoin implements Runnable {


    public static void main(String[] sure) throws InterruptedException {
        Thread t = new Thread(new TestJoin());
        long start = System.currentTimeMillis();
        t.start();
        t.join(1000);//等待執行緒t 1000毫秒
        System.out.println(System.currentTimeMillis()-start);//打印出時間間隔
        System.out.println("Main finished");//列印主執行緒結束
    }

    @Override
    public void run() {
       // synchronized (currentThread()) {
            for (int i = 1; i <= 5; i++) {
                try {
                    sleep(1000);//睡眠5秒，迴圈是為了方便輸出資訊
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("睡眠" + i);
            }
            System.out.println("TestJoin finished");//t執行緒結束
        }
    //}
}

在註釋掉synchronized修飾的run方法後，列印資訊如下：

可以看到main執行緒等待了t執行緒1000毫秒之後，結束了，隨後是t執行緒列印的資料。

那麼如果加上run方法的synchronized那條語句呢？結果如下：

由於先呼叫了t.start()方法，執行緒進入synchronized程式碼段，main執行緒等待一秒以後，還是得不到執行緒t的物件鎖，只能繼續等待，直到執行緒t結束，釋放鎖。這裡可以明確看到main執行緒等待時間是5000ms，有些文章裡寫的是t執行緒執行時間+join方法指定的時間（5000+1000 ），其實不是的，這裡可以很清晰的看到，main執行緒等待時間只有5000ms，看到有的文章說join呼叫的wait也是需要獲取物件鎖的。

JDK原始碼中wait操作是

public final native void wait(long timeout) throws InterruptedException;

wait內部實現應該是用synchronized，等待時間是5000+1000就好解釋了，搞不明白。

此處存疑。

轉自： http://www.cnblogs.com/aboutblank/p/3631453.html