Java 多线程之Join

   方法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) ; // 主线程只等1 秒，不管子线程什么时候结束
            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) 　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