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

猜你喜欢