java多线程中对于join方法的理解

对于多线程的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. 字面意思是join用于主线程等待子线程运行完毕它的run方法，再继续执行下面的代码。例如：

public class JoinTest {    public static void main(String[] args) {        Thread t =  new  Thread( new  RunnableImpl());        t.start();        try {           t.join();//t线程完成run方法后才会继续执行下面的代码！        }  catch  (Exception e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        Thread t1 =  new  Thread( new  RunnableImpl1());        t1.start();    }

就是说如果是t.join() = t.join(0) JDK 这样说的 A timeout of 0 means to wait forever 字面意思是永远等待，其实是等到t 结束后。

JDK源码如下：

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 毫秒了。上代码介绍：

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