深入浅出Java多线程（1）-方法 join

    对于Java开发人员，多线程应该是必须熟练应用的知识点，特别是开发基于Java语言的产品。本文将深入浅出的表述Java多线程的知识点，在后续的系列里将侧重于Java5由Doug Lea教授提供的Concurrent并行包的设计思想以及具体实现与应用。
    如何才能深入浅出呢，我的理解是带着问题，而不是泛泛的看。所以该系列基本以解决问题为主，当然我也非常希望读者能够提出更好的解决问题的方案以及提出更 多的问题。由于水平有限，如果有什么错误之处，请大家提出，共同讨论，总之，我希望通过该系列我们能够深入理解Java多线程来解决我们实际开发的问题。
    作为开发人员，我想没有必要讨论多线程的基础知识，比如什么是线程？ 如何创建等 ，这些知识点是可以通过书本和Google获得的。本系列主要是如何理深入解多线程来帮助我们平时的开发，比如线程池如何实现？ 如何应用锁等。 

（1）方法Join是干啥用的？ 简单回答，同步，如何同步？ 怎么实现的？ 下面将逐个回答。
    自从接触Java多线程，一直对Join理解不了。JDK是这样说的：

title="Style" href="http://www.blogjava.net/j2se6/api/stylesheet.css" type="text/css" rel="stylesheet"> <script type="text/javascript"> function windowTitle() { if (location.href.indexOf('is-external=true') == -1) { parent.document.title="Thread (Java Platform SE 6)"; } } </script> <script language="JScript" src="http://www.blogjava.net/j2se6/H2HHinclude.js"></script>    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

小结：
本节主要深入浅出join及ＪＤＫ中的实现。
在下一节中，我们将要讨论SWing 中的事件方法线程来解决一个网友问到的问题：
如何控制Swing程序在单机只有一个实例，也就是不能运行第二个Main方法。