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