join和wait
最近看多线程的时候发现对于join的理解有些错误，在网上查了不少资料，根据自己的理解整理了一下，这里之所以把join和wait放在一起，是因为join的底层实现就是基于wait的，一并讲解更容易理解。
wait
了解join就先需要了解wait，wait是线程间通信常用的信号量，作用就是让线程暂时停止运行，等待其他线程使用notify来唤醒或者达到一定条件自己苏醒。
wait是一个本地方法，属于Object类，其底层实现是JVM内部实现，是基于monitor对象监视锁。
//本地方法
public final native void wait(long timeout) throws InterruptedException;
//参数有纳秒和毫秒
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
//存在纳秒，默认加一毫秒
if (nanos > 0) {
timeout++;
}
wait(timeout);
}
//无参数，默认为0
public final void wait() throws InterruptedException {
wait(0);
}
根据源码可以发现，虽然wait有三个重载的方法，但是主要的还是wait(long timeout)这个本地方法，其他两个都是基于这个来封装的，由JVM底层源码不太好看到，我就以流程的形式来描述。
synchronized (this) {
System.out.println("A begin " + System.currentTimeMillis());
try {
wait(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("A end " + System.currentTimeMillis());
}
- 上述代码在执行到wait(5000)时首先会释放当前占用的锁，并暂停线程。
- 在暂停的5秒内如果收到其他线程的notify()方法发来的信号，那么就再次尝试获取已经释放的锁
- 如果获取到那么就继续执行，没有就等待锁释放来竞争。
- 如果在5秒内未收到信号，那么到时间后就自动苏醒去尝试获取锁。
而对于时间的参数timeout需要注意的是，如果输入0不代表不暂停，而是需要特殊情况自己苏醒或者notify唤醒，这里有个特殊点，wait(0)是可以自己苏醒的。
public class Thread2 extends Thread{
private Thread1 a;
public Thread2(Thread1 a) {
this.a = a;
}
@Override
public void run() {
synchronized (a) {
System.out.println("B begin " + System.currentTimeMillis());
try {
a.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("B end " + System.currentTimeMillis());
}
}
}
public class Thread1 extends Thread{
@Override
public void run() {
synchronized (this) {
System.out.println("A begin " + System.currentTimeMillis());
System.out.println("A end " + System.currentTimeMillis());
}
}
}
public class Main{
public static void main(String[] args) {
Thread1 thread = new Thread1();
Thread2 thread2 = new Thread2(thread);
thread2.start();
thread.start();
System.out.println("main end "+System.currentTimeMillis());
}
}
这个例子运行结果存在以下情况
B begin 1494995803564
main end 1494995803565
A begin 1494995803565
A end 1494995803565
B end 1494995803565
wait()在没有notify()情况下自动苏醒了，因此这里可以看到，当前情况下Thread.wait()等待过程中，如果Thread结束了，是可以自动唤醒的。这个会在join中被使用。
join
了解了wait的实现原理之后就可以来看join了，join是Thread类的方法，不是底层本地方法，这里可以看一下它的源码。
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
//参数判断<0,抛异常
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
//参数为0，即join()
if (millis == 0) {
//当前线程存活，就调用wait(0)，一直到调用join的线程结束再自动苏醒
while (isAlive()) {
wait(0);
}
//参数>0，调用wait(long millis)等待一段时间后自动唤醒
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
public final synchronized void join(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
join(millis);
}
public final void join() throws InterruptedException {
join(0);
}
很明显，join的三个重载方法主要还是基于join(long millis)方法，因此我们主要关注这个方法，方法的处理逻辑如下
- 判断参数时间参数，如果参数小于0，抛出IllegalArgumentException("timeout value is negative")异常
- 参数等于0，判断调用join的线程(假设是A)是否存活，不存活就不执行操作，如果存活，就调用wait(0)，阻塞join方法，等待A线程执行完在结束join方法。
- 参数大于0，判断调用join的A线程是否存活，不存活就不执行操作，如果存活，就调用wait(long millis)，阻塞join方法，等待时间结束再继续执行join方法。
由于join是synchronized修饰的同步方法，因此会出现join(long millis)阻塞时间超过了millis的值。
public class Thread1 extends Thread{
@Override
public void run() {
synchronized (this) {
System.out.println("A begin " + System.currentTimeMillis());
try {
sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("A end " + System.currentTimeMillis());
}
}
}
public class Main{
public static void main(String[] args) {
Thread1 thread = new Thread1();
thread.start();
try {
thread.join(1000);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("main end "+System.currentTimeMillis());
}
}
这个例子的运行结果是
A begin 1494996862054
A end 1494996867056
main end 1494996867056
main线程一定是最后执行完的，按照流程来说，1秒之后阻塞就结束了，main线程应该就可以开始执行了，但是这里有一个注意点，join(long millis)在执行millis>0的时候在wait(delay)之后还有一行代码，而上面代码1秒之后只是结束了wait方法，并没有执行完join方法。上面的例子，由于join的锁和thread的锁相同，在thread运行完之前，锁不会释放，那么导致join一直阻塞在最后一步无法结束，才会出现上面的情况。
