线程的通知与等待
Java中的Object类是所有类的父类，鉴于继承机制，Java把所有的类都需的方法放在了Object类里面，其中就包含要说的通知与等待。
1.wait()方法
当一个线程调用一个共享变量的wait() 方法时,该调用线程会被阻塞挂起,直到发生下面几件事情之一才返回。
1.其他线程调用了该共享对象的notify() 或者notifyAll() 方法。
2.其他线程调用了该线程的interrupt() 方法，该线程抛出InterruptedException 异常返回
另外需要注意的是，如果调用wait() 方法的线程没有事先获取该对象的监视器锁，则调用wait()方法时调用线程会抛出 IllegalMonitorStateException异常。
那么一个线程如何才能获取一个共享变量的监视器锁呢?
1.执行synchronized同步代码块时使用该共享变量作为参数。
synchronized(共享变量){
// doSomething
} 2.调用该共享变量的方法，并且该方法使用了 synchronized 修饰。
synchronized void method(int a, int b){
// doSomething
}另外需要注意的时，一个线程可以从挂起状态变为可以运行的状态(也就是被唤醒)，即使该线程没有被其他线程调用notify(), notifyAll() 方法进行通知，或者被中断，或者等待超时。也就是所谓的虚假唤醒。
虽然虚假唤醒在应用实践中很少发生，但要防患于未然，做法就是不停地去测试该线程被唤醒状态的条件是否满足，不满足则继续等待，也就是说在一个循环中调用**wait()**方法进行防范。退出循环的条件就是满足了唤醒该线程的条件。
synchronized (obj) {
while(条件不满足){
obj.wait();
}
}如上代码呢也是经典的调用共享变量wait()方法的实例，首先通过同步块获取obj上面的监视器锁，然后再while 循环内调用obj的wait()方法。
下面从一个简单的生产者和消费者例子来加深下理解。如下面代码所示，其中queue为共享变量，生产者线程在调用queue的wait()方法前，使用synchronized关键字拿到了该共享变量queue的监视器锁，所以调用wait()方法不会抛出 IllegalMonitorStateException 异常。如果当前队列没有空闲容量则会调用wait()方法挂起当前线程，这里使用循环是为了避免上面说的虚假唤醒。假如当前线程被虚假唤醒了，但是队列还是没有空余的容量，那么当前线程还是会调用wait()方法把自己挂起。
public class ObjectMethodTest {
Queue<String> queue = new LinkedList<String>();
int MAX_SIZE = 1; // 假设队列长度只有1 ， 只能存放一条数据
public void produce(){
synchronized (queue){
// 队列满则等待队列空间
while (queue.size() == MAX_SIZE) {
// 挂起当前线程，并释放通过同步块获取的queue上的锁，让消费者线程可以获取该锁，然后获取队列里面的元素。
try {
queue.wait();
System.out.println("-----等待消费----");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.add("hahaha");
queue.notifyAll();
}
}
public void consume(){
synchronized (queue) {
while (queue.size() == 0) {
// 挂起当前线程，并释放通过同步块获取的queue上的锁，让消费者线程可以获取该锁，然后获取队列里面的元素。
try {
queue.wait();
System.out.println("-----等待生产-----");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 消费元素, 并通知唤醒生产者
System.out.println("消费成功:" + queue.poll());
queue.notifyAll();
}
}
public static void main(String[] args) {
ObjectMethodTest objectMethodTest = new ObjectMethodTest();
// 10 个生产线程
for (int i = 0; i < 10; i++) {
new Thread(objectMethodTest::produce).start();
}
// 10 个消费线程
for (int i = 0; i < 10; i++) {
new Thread(objectMethodTest::consume).start();
}
}
}
在如上代码中，假如生产者线程A首先通过synchronized获取到了queue上的锁，那么后续所有企图生产的线程和消费的线程 都将会在获取该监视器锁的地方被阻塞挂起。线程A获取锁后发现队列已满会调用wait()方法阻塞挂起自己，然后就会释放掉获取到的queue上的锁，防止发生死锁。
另外需要注意的是，当前线程调用共享变量的wait()方法后指挥释放当前共享变量上的锁，如果当前线程还持有其他共享变量的锁，则这些锁是不会被释放的，接下来看例子。
public class WaitTest {
private static volatile Object resourceA = new Object();
private static volatile Object resourceB = new Object();
public static void main(String[] args) throws InterruptedException {
// 创建线程
Thread threadA = new Thread(() -> {
try {
synchronized (resourceA) {
System.out.println("threadA 获取到resourceA的锁");
synchronized (resourceB){
System.out.println("threadA 获取到 resourceB的锁");
System.out.println("threadA 释放掉 resourceA的锁");
resourceA.wait();
}
}
}catch (Exception ex) {
ex.printStackTrace();
}
});
// 创建线程
Thread threadB = new Thread(() -> {
try {
Thread.sleep(1000);
synchronized (resourceA) {
System.out.println("threadB 获取到resourceA的锁");
System.out.println("threadB 尝试获取resourceB的锁*****");
synchronized (resourceB){
System.out.println("threadB 获取到 resourceB的锁");
System.out.println("threadB 释放掉 resourceA的锁");
resourceA.wait();
}
}
}catch (Exception ex) {
ex.printStackTrace();
}
});
threadA.start();
threadB.start();
threadA.join();
threadB.join();
}
}
如上代码在main方法里 启动了 A,B两个线程，为了让A先获取到锁，这里让线程B休眠了1s，线程A先后获取到了共享变量resourceA和resourceB上的锁，然后调用了resourceA的wait()方法阻塞挂起自己，阻塞自己后线程A释放掉了获取到的resourceA上的锁。
线程B休眠后结束后会先尝试获取resourceA上的锁，如果当前线程A里边还没有调用resourceA的wait()方法阻塞挂起释放掉该锁，那么线程B就会被阻塞，如果线程A释放了resourceA的锁后，线程B就会获取到resourceA上的锁，然后尝试获取resourceB上的锁。由于线程A中没有释放锁，所以导致线程B尝试获取resourceB上的锁时会被阻塞。
以上就证明了当前线程调用共享变量对象的wait()方法时，当前线程只会释放当前共享对象的锁，当前线程持有其他共享对象的监视器锁并不会被释放。
这里再举个例子说明当一个线程调用共享对象的wait()方法被阻塞挂起后，如果其他线程中断了该线程，则该线程会抛出InterruptedException异常返回。
public class WaitNotifyInterrupt {
static Object obj = new Object();
public static void main(String[] args) throws InterruptedException {
Thread testThread = new Thread(() -> {
try {
System.out.println("----begin----");
// 阻塞当前线程
synchronized (obj) {
obj.wait();
}
System.out.println("---end---");
} catch (Exception ex) {
ex.printStackTrace();
}
});
testThread.start();
Thread.sleep(1000);
System.out.println("开始阻断 testThread");
testThread.interrupt();
System.out.println("阻塞 testThread 完毕");
}
}
如上代码，testThread调用了共享变量obj的wait()方法后阻塞挂起了自己，然后主线程休眠1s后中断了testThread线程，中断后testThread再obj.wait()处抛出了java.lang.InterruptedException 异常而返回并终止。
2.wait(long timeout)方法
该方法相比于wait()方法多了一个超时参数，它的不同之处在于，如果一个线程调用共享变量的该方法挂起后，没有再指定的timeout ms时间内被其他线程调用该共享变量的notify()或者notifyAll()方法唤醒，那么该函数还是因为超时而返回。如果将timeoout设置为0那么则和wait()方法效果一样，因为wait()方法内部就是调用了wait(0)，需要注意的是，如果在调用该方法时，传递了一个负的timeout则会抛出IllegalArgumentException异常。
3.wait(long timeout, int nanos)方法
在内部调用的是wait(long timeout)函数，如下代码只用nanos>0时才使timeout参数递增1。
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);
}4.notify()方法
一个线程调用共享对象的notify方法后，会唤醒一个在该共享变量上调用wait系列方法后被阻塞挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。
此外，被唤醒的线程不能马上从wait方法返回并继续执行，它必须在获取了共享对象的监视器锁后才可以返回，也就是唤醒它的线程释放了共享变量上的监视器锁后，被唤醒的线程也不一定会获取到共享变量的监视器锁，这是因为该线程还需要和其他线程一起竞争该锁，只有该线程竞争到了共享变量的监视器锁后才能继续执行。
类似wait()系列方法，只有当前线程获取到了共享变量的监视器锁后，才可以调用共享变量的notify()方法，否则会抛出 IllegalMonitorStateException异常。
5.notifyAll()方法
不同于在共享变量上调用notify()，会唤醒被阻塞到该共享变量上的一个线程，notifyAll()方法则会唤醒所有在该共享变量由于调用wait()系列方法而被挂起的线程。
下面举个例子来说明notify()和notifyAll()方法具体含义以及一些需要注意的地方。
public class NotifyTest {
private static volatile Object resourceA = new Object();
public static void main(String[] args) throws InterruptedException {
// 创建线程
Thread threadA = new Thread(() -> {
// 获取resourceA的共享资源锁
synchronized (resourceA) {
System.out.println("threadA 获取到 resourceA 的锁");
try {
System.out.println("threadA 开始调用resourceA的wait()方法进行阻塞挂起");
resourceA.wait();
System.out.println("threadA 结束等待");
} catch (Exception ex) {
ex.printStackTrace();
}
}
});
// 创建线程
Thread threadB = new Thread(() -> {
synchronized (resourceA) {
System.out.println("threadB 获取到 resourceA 的锁");
try {
System.out.println("threadB 开始调用resourceA的wait()方法进行阻塞挂起");
resourceA.wait();
System.out.println("threadB 结束等待");
} catch (Exception ex) {
ex.printStackTrace();
}
}
});
// 创建线程
Thread threadC = new Thread(() -> {
synchronized (resourceA) {
System.out.println("threadC 开始调用 resourceA的notify()方法");
resourceA.notify();
}
});
// 启动线程
threadA.start();
threadB.start();
Thread.sleep(1000);
threadC.start();
// 等待线程执行结束
threadA.join();
threadB.join();
threadC.join();
System.out.println("end---------------------");
}
}
如上代码开启了三个线程，其中A,B线程分别调用了resourceA的wait()方法，线程C在主线程休眠1s后调用了notify()方法。主线程休息1s是为了保证让线程A,B全部执行完wait()方法后再调用线程C的notify()方法。
这个例子试图再线程A和线程B都因调用共享资源resourceA的wait()方法而被阻塞后，让线程C调用resourceA的notify()方法，从而唤醒线程A,B。但是从执行结果来看，只有一个线程A被唤醒，线程B依然在阻塞挂起状态。
从输出结果可知线程调度器这次先调度了线程A占用Cpu来运行，线程A先获取到resourceA的资源所，然后调用wait()方法阻塞挂起，释放锁，而后线程B获取到资源锁，调用resourceA的wait()阻塞挂起。然后线程C调用notify()方法，尝试唤醒线程，这回激活resourceA的阻塞集合里面的一个线程，这里激活了线程A，所以线程A方法执行完毕并返回了。线程B则继续在阻塞等待中。如果把notify()方法换成notifyAll()结果会这样。
换成notifyAll()方法后，可以看到都得到了唤醒。因为上边也说过了notifyAll()方法会唤醒共享变量内所有的等待线程。这里就是唤醒了resourceA的等待集合里所有线程。只是线程B先抢到了resourceA上的锁，然后返回。然后线程A抢到也进行了返回。
尝试把主线程里面的休眠1s去掉，看一下执行结果。
线程B没有正常被唤醒。
这是因为线程C可能比线程B先执行了。如果调用notifyAll()方法后一个线程调用了该共享变量的wait()方法而被放到阻塞集合，则该线程不会被唤醒的，指挥唤醒执行notifyAll()方法前阻塞集合里的所有线程。
对wait(),notify(),notifyAll()的说明结束了