深入淺出Java多線程-方法join (裝)

對於Java開發人員，多線程應該是必須熟練應用的知識點，特別是開發基於Java語言的產品。本文將深入淺出的表述Java多線程的知識點，在後續的系列裡將側重於Java5由Doug Lea教授提供的Concurrent並行包的設計思想以及具體實現與應用。

如何才能深入淺出呢，我的理解是帶著問題，而不是泛泛的看。所以該系列基本以解決問題為主，當然我也非常希望讀者能夠提出更好的問題的解決方案以及提出更多的問題。由於水平有限，如果有什麼錯誤之處，請大家提出，共同討論，總之，我希望通過該系列我們能夠深入理解Java多線程來解決我們實際開發的問題。

作為開發人員，我想沒有必要討論多線程的基礎知識，比如什麼是線程？ 如何建立等 ，這些知識點是可以通過書本和Google獲得的。本系列主要是如何理深入解多線程來協助我們平時的開發，比如線程池如何?？ 如何應用鎖等。

（1）方法Join是幹啥用的？ 簡單回答，同步，如何同步？ 怎麼實現的？ 下面將逐個回答。

自從接觸Java多線程，一直對Join理解不了。JDK是這樣說的：join public final void join（long millis）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.大家能理解嗎？ 字面意思是等待一段時間直到這個線程死亡，我的疑問是那個線程，是它本身的線程還是調用它的線程的，上代碼：

package concurrentstudy;
/**
*
* @author vma
*/
public class JoinTest {
public static void main(String[] args) {
Thread t = new Thread(new RunnableImpl());
t.start();
try {
t.join(1000);
System.out.println("joinFinish");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();

}
}
}
class RunnableImpl implements Runnable {

@Override
public void run() {
try {
System.out.println("Begin sleep");
Thread.sleep(1000);
System.out.println("End sleep");
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}
結果是：
Begin sleep
End sleep
joinFinish
明白了吧，當main線程調用t.join時，main線程等待t線程，等待時間是1000，如果t線程Sleep 2000呢
public void run() {
try {
System.out.println("Begin sleep");
// Thread.sleep(1000);
Thread.sleep(2000);
System.out.println("End sleep");
} catch (InterruptedException e) {
e.printStackTrace();
}

}
結果是：
Begin sleep
joinFinish
End sleep
也就是說main線程只等1000毫秒，不管T什麼時候結束，如果是t.join()呢， 看代碼：
public final void join() throws InterruptedException {
join(0);
}
就是說如果是t.join() = t.join(0) 0　JDK這樣說的 A timeout of 0 means to wait forever 字面意思是永遠等待，是這樣嗎？
其實是等到t結束後。
這個是怎麼實現的嗎？ 看JDK代碼：
/**
* Waits at most <code>millis</code> milliseconds for this thread to
* die. A timeout of <code>0</code> means to wait forever.
*
* @param millis the time to wait in milliseconds.
* @exception InterruptedException if any thread has interrupted
* the current thread. The <i>interrupted status</i> of the
* current thread is cleared when this exception is thrown.
*/
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方法實現是通過wait（小提示：Object 提供的方法）。 當main線程調用t.join時候，main線程會獲得線程對象t的鎖（wait 意味著拿到該對象的鎖),調用該對象的wait(等待時間)，直到該對象喚醒main線程，比如退出後。

這就意味著main 線程調用t.join時，必須能夠拿到線程t對象的鎖，如果拿不到它是無法wait的，剛開的例子t.join(1000)不是說明了main線程等待1秒，如果在它等待之前，其他線程擷取了t對象的鎖，它等待時間可不就是1毫秒了。上代碼介紹：

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package concurrentstudy;
/**
*
* @author vma
*/
public class JoinTest {
public static void main(String[] args) {
Thread t = new Thread(new RunnableImpl());
new ThreadTest(t).start();
t.start();
try {
t.join();
System.out.println("joinFinish");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();

}
}
}
class ThreadTest extends Thread {

Thread thread;

public ThreadTest(Thread thread) {
this.thread = thread;
}

@Override
public void run() {
holdThreadLock();
}

public void holdThreadLock() {
synchronized (thread) {
System.out.println("getObjectLock");
try {
Thread.sleep(9000);

} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("ReleaseObjectLock");
}

}
}

class RunnableImpl implements Runnable {

@Override
public void run() {
try {
System.out.println("Begin sleep");
Thread.sleep(2000);
System.out.println("End sleep");
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}

在main方法中 通過new ThreadTest(t).start();執行個體化ThreadTest 線程對象， 它在holdThreadLock()方法中，通過 synchronized (thread)，擷取線程對象t的鎖，並Sleep（9000）後釋放，這就意味著，即使
main方法t.join(1000),等待一秒鐘，它必須等待ThreadTest 線程釋放t鎖後才能進入wait方法中，它實際等待時間是9000+1000 MS
運行結果是：
getObjectLock
Begin sleep
End sleep
ReleaseObjectLock
joinFinish