1 定义
虚假唤醒，即spurious wakeups。wait需要在while循环内使用，原因就是因为存在虚假唤醒。
2 Monitor
还是放上这个神图来复习下线程间通信
- 线程在竞争锁失败的情况下会放到Entry Set中，图中2表示线程可以获取锁
- 获取到锁的线程可以调用wait方法，让线程阻塞，此时线程被放到了Wait Set中，如图中3所示；Wait Set中的线程在时间到或者被notify后可以竞争锁，如图中4所示
- Wait Set中的线程在获取到锁后才可以继续执行。
- notify只会将Wait Set中的一个随机线程移到Entry Set来竞争锁，notifyAll会将全部线程由Wait Set移到Entry Set，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在Entry Set等待锁被释放后再次参与竞争。
- notify和notifyAll的作用可以直观的认为就是将线程从Wait Set挪到Entry Set
3 虚假唤醒
我们以生产者消费者问题来举例几种情况，假设在wait在if中而不是在while中
1）情况1 稍微复杂点
- 有一个生产者p，两个消费者c1、c2，一个队列queue
- c1先执行，由于queue中为0，所以c1调用wait线程阻塞，线程放到了Wait Set中
- p生产了一个消费，放到queue中
- 在p调用notify之前，c2开始执行，需要竞争queue的锁，所以c2在Entry Set等待竞争锁
- p生产完成，调用notify，c1收到被唤醒后，从Wait Set竞争锁，注意此时c2也在竞争锁。
- c2从Entry Set先竞争到锁，然后消费了queue中的消息，此时queue大小为0
- c2执行完后，释放锁，此时c1竞争到锁，从queue中消费消息，由于queue目前大小为0，所以从queue为0的队列中访问是非法的。
2）情况2 稍微简单点
- 有一个生产者p，两个消费者c1、c2，一个队列queue
- c1、c2先启动，由于queue是空，所以分别调用wait，c1、c2都进入Wait Set
- 之后p生产了一个消息到queue中，然后调用notifyall，c1和c2都被唤醒。
- c1竞争到锁，消费一个消息，queue大小为0，完成后释放锁
- c2竞争到锁，消费一条消息，queue大小是-1，抛出异常。
3）情况3
- 假设有两种情况会引起消费者阻塞
- c1是由于条件1，调用了wait；c2是由于条件2调用了wait；
- p生产了一条消息，然后满足了条件1，调用notify，却唤醒了c2
- 由于是使用的if，c2没有再判断是不是条件2被满足了，所以就直接获取到锁，造成错误
4）情况4
- wait可能被interrupt等不被唤醒就继续执行
总结：其实可以总结为一句话就是wait被唤醒后，可能还是没有满足继续允许的条件，原因可能是被其他线程争夺了也可能是notifyAll了无关的它，所以需要重新去检查下条件
4 举例
我们以情况2来举例
public class ProducerConsumer {
public static void main(String[] args) throws Exception{
new ProducerConsumer().test();
}
public void test() throws InterruptedException {
Queue<Integer> queue = new LinkedList<>();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue, 0);
Consumer consumer1 = new Consumer(queue, 1);
ExecutorService executor = Executors.newFixedThreadPool(6);
executor.submit(consumer);
executor.submit(consumer1);
Thread.sleep(5000);
executor.submit(producer);
}
class Producer implements Runnable {
private Queue<Integer> queue;
public Producer(Queue<Integer> queue) {
this.queue = queue;
}
@Override
public void run(){
Thread.currentThread().setName("consumerThread_" + index);
while (true) {
try {
synchronized (queue) {
if (queue.size() <= 0) {
try {
System.out.println("consumer wait:" + Thread.currentThread().getName());
queue.wait();
System.out.println("consumer wait2:" + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("gogogo:" + Thread.currentThread().getName());
Integer time = new Random().nextInt(100);
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("consumer remove: " + queue.remove() + ": " + Thread.currentThread().getName());
queue.notifyAll();
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
运行结果
consumer wait:consumerThread_0
consumer wait:consumerThread_1
producer notifyall
consumer wait2:consumerThread_1
gogogo:consumerThread_1
consumer remove: 99: consumerThread_1
consumer wait:consumerThread_1
consumer wait2:consumerThread_0
gogogo:consumerThread_0
java.util.NoSuchElementException
at java.util.LinkedList.removeFirst(LinkedList.java:270)
at java.util.LinkedList.remove(LinkedList.java:685)
at com.hxy.ProducerConsumer$Consumer.run(ProducerConsumer.java:85)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
上述代码中，两个消费者先启动，由于queue.size 小于等于0 ，所以两个消费者都调用wait，放到了Wait Set中；5s后生产者往队列里发送了一条消息，然后调用notifyAll，两个消费者都被唤醒，由于没有再判断是否满足条件，所以分别获取锁去消费，造成第二个消费者抛出NoSuchElementException异常。
将上述代码中消费者的if判断修改为while便会正常，运行结果如下：
consumer wait:consumerThread_0
consumer wait:consumerThread_1
producer notifyall
consumer wait2:consumerThread_1
gogogo:consumerThread_1
consumer remove: 53: consumerThread_1
consumer wait:consumerThread_1
consumer wait2:consumerThread_0
consumer wait:consumerThread_0
consumerThread_0竞争到锁后，会从while判断queue.size大小，由于queue大小为0，所以继续wait。
另外，可能会想到，在while使用wait，对于情况3这种情况，如果调用notifyall，会唤醒其他不相关的线程，而这些线程需要重新判断，然后再调用wait，这显然是一种资源浪费。针对这种情况，我们可以使用Condition，只唤醒相关的线程。
5 生产者消费者
下面附上正确的消费者生产者
public class ProducerConsumer {
public static void main(String[] args) throws Exception{
new ProducerConsumer().test();
}
public void test() throws InterruptedException {
Queue<Integer> queue = new LinkedList<>();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue, 0);
Consumer consumer1 = new Consumer(queue, 1);
ExecutorService executor = Executors.newFixedThreadPool(6);
executor.submit(consumer);
executor.submit(consumer1);
executor.submit(producer);
}
class Producer implements Runnable {
private Queue<Integer> queue;
public Producer(Queue<Integer> queue) {
this.queue = queue;
}
@Override
public void run(){
while (true) {
try {
synchronized (queue) {
while (queue.size() >= 10) { // 防止虚假唤醒
queue.wait();
}
Integer time = new Random().nextInt(100);
Thread.sleep(time);
System.out.println("producer add:" + time);
queue.add(time);
queue.notifyAll();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable {
private Queue<Integer> queue;
private int index;
public Consumer(Queue<Integer> queue, int i) {
this.queue = queue;
this.index = i;
}
@Override
public void run() {
Thread.currentThread().setName("consumerThread_" + index);
while (true) {
try {
synchronized (queue) {
while (queue.size() <= 0) { // 防止虚假唤醒
queue.wait();
}
Integer time = new Random().nextInt(100);
Thread.sleep(time);
System.out.println("consumer remove: " + queue.remove() + ": " + Thread.currentThread().getName());
queue.notifyAll(); // 也有可能唤醒另一个consumer中的queue.wait
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
使用condition的生产者和消费者
public class ProducerConsumer {
private Lock lock = new ReentrantLock();
private Condition notFull = lock.newCondition(); // 两个condition队列
private Condition notEmpty = lock.newCondition();
public static void main(String[] args) throws Exception{
new ProducerConsumer().test();
}
public void test() throws InterruptedException {
Queue<Integer> queue = new LinkedList<>();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue, 0);
Consumer consumer1 = new Consumer(queue, 1);
ExecutorService executor = Executors.newFixedThreadPool(6);
executor.submit(consumer);
executor.submit(consumer1);
executor.submit(producer);
}
class Producer implements Runnable {
private Queue<Integer> queue;
public Producer(Queue<Integer> queue) {
this.queue = queue;
}
@Override
public void run(){
while (true) {
lock.lock();
try {
while (queue.size() >= 10) { // 防止虚假唤醒
notFull.await(); // 注意是await，表示等待直到queue不满；可以理解为等待队列不满
}
Integer time = new Random().nextInt(100);
Thread.sleep(time);
System.out.println("producer add:" + time);
queue.add(time);
notEmpty.signalAll(); // 注意是signal, 写入一条数据，然后通知不空；可以理解为周知队列不空
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
class Consumer implements Runnable {
private Queue<Integer> queue;
private int index;
public Consumer(Queue<Integer> queue, int i) {
this.queue = queue;
this.index = i;
}
@Override
public void run() {
Thread.currentThread().setName("consumerThread_" + index);
while (true) {
lock.lock();
try {
while (queue.size() <= 0) { // 防止虚假唤醒
notEmpty.await(); // 注意是await，表示等待直到queue不空;可以理解为等待队列不空
}
Integer time = new Random().nextInt(100);
Thread.sleep(time);
System.out.println("consumer remove: " + queue.remove() + ": " + Thread.currentThread().getName());
notFull.signalAll(); // 注意是signal, 消费了一条数据，然后通知不满;可以理解周知队列不满
}catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
}
6 notify死锁问题
考虑一种场景：队列大小是1，有一个生产者叫做p，两个消费者叫做c1、c2; c1和c2先启动，由于队列为空，所在都wait在wait set; p随后生产了一个消息调用notify，然后由于队列由于队列满了所以wait在wait set；假设p随机唤醒的是c1，那么c1消费完队列中的一个消息后会notify，notify会随机选择一个wait set中的线程，注意，此时c2和p都在wait set，假设唤醒的是c2，则c2由于检查到队列为空则wait，p则无人再唤醒了，这个时候就产生了死锁。如果是调用的notifyAll的话，则p和c2都会被唤醒，就会避免这种情况的发生。可以参考：https://www.jianshu.com/p/45626f4e0fc1
其实notify死锁的本质原因是notify是随机唤醒的，并不一定能唤醒我们需要的线程