一、前言
通过一个简单的例子引入join()方法
public class Thread01 extends Thread{
@Override
public void run() {
for(int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "=" + i);
}
}
}
main线程中起两个线程
public class Test {
public static void main(String[] args) throws InterruptedException {
Thread01 thread01 = new Thread01();
Thread01 thread02 = new Thread01();
thread01.start();
thread02.start();
}
}
结果：
Thread-1=0
Thread-0=0
Thread-0=1
Thread-0=2
Thread-1=1
Thread-0=3
Thread-1=2
Thread-0=4
Thread-1=3
Thread-1=4
说明：可以看到，thread01和thread02并发执行，没有先后顺序，现在在thread01.start()之后加入join()方法
public class Test {
public static void main(String[] args) throws InterruptedException {
Thread01 thread01 = new Thread01();
Thread01 thread02 = new Thread01();
thread01.start();
thread01.join();
System.out.println("main thread after join");
thread02.start();
}
}
其他不变，看一下结果：
Thread-0=0
Thread-0=1
Thread-0=2
Thread-0=3
Thread-0=4
main thread after join
Thread-1=0
Thread-1=1
Thread-1=2
Thread-1=3
Thread-1=4
说明：可以看到，thread01在调用join()后，会优先执行，等它执行完了，才会执行thread02。在分析main线程中的执行过程之前，先看一下join()方法的源码。
二、join()/join(long millis)
/**
* Waits for this thread to die.
*
* <p> An invocation of this method behaves in exactly the same
* way as the invocation
*
* <blockquote>
* {@linkplain #join(long) join}{@code (0)}
* </blockquote>
*
* @throws 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 void join() throws InterruptedException {
join(0);
}
join()方法调用了join(long millis)方法
/**
* Waits at most {@code millis} milliseconds for this thread to
* die. A timeout of {@code 0} means to wait forever.
*
* <p> This implementation uses a loop of {@code this.wait} calls
* conditioned on {@code this.isAlive}. As a thread terminates the
* {@code this.notifyAll} method is invoked. It is recommended that
* applications not use {@code wait}, {@code notify}, or
* {@code notifyAll} on {@code Thread} instances.
*
* @param millis
* the time to wait in milliseconds
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative
*
* @throws 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(long millis)是同步方法，该方法是通过循环判断线程的isAlive的值（调用join方法的线程）来调用wait方法。当有线程执行完了，notifyAll方法会被调用，使其他处于等待的线程开始执行。
分析一下main方法中的执行过程。在main线程中，首先thread01依次调用start()-->join()-->join(0)方法，因为join(long millis)是同步方法，main线程会去获取与thread01对象关联的monitor的所有权（The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref），thread01对象关联的monitor还没有被别的线程所有，所以main线程进入该同步方法，传入的参数millis为0，接着判断thread01线程isAlive（Tests if this thread is alive. A thread is alive if it has been started and has not yet died），为true，调用wait()方法，main线程处于等待状态，而thread01线程继续执行，当thread01线程执行完毕，join(long millis)方法结束，notifyAll()方法会被调用，main线程被唤醒，继续执行，打印出"main thread after join"语句，执行thread02线程。