方法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
人生就像是一场旅行，遇到的既有感人的，
