多线程wait()判断条件这个地方的逻辑琢磨了挺久的，本意就是拿到锁之后如果条件不满足就等待，感觉用if和while似乎没啥区别
首先是生产者，单独一个线程，和消费者共用一个锁和一个队列，都通过构造方法传入
1.线程里直接死循环持续生产消息，消息体最好不一样，可以弄个随机数，我这里用了微妙时间戳，调用add()方法
2.需要添加一个条件，如果队列已经满了，就不能继续添加了，调用wait()方法等待被其它线程消费了之后唤醒
3.生产完消息后，调用notifyAll()方法，唤醒等待的所有线程，直到synchronized全部执行完之后，释放lock锁供其它线程竞争来消费
package com.lihuia.multithreading;
import java.util.Queue;
/**
* Copyright (C), 2018-2019
* FileName: ProducerThread
* Author: lihui
* Date: 2019-09-09
*/
public class ProducerThread implements Runnable {
private Object lock;
private Queue<String> queue;
private final int MAX_SIZE = 5;
public ProducerThread(Object lock, Queue<String> queue) {
this.lock = lock;
this.queue = queue;
}
@Override
public void run() {
while (true) {
synchronized (lock) {
while (queue.size() >= MAX_SIZE) {
try {
System.out.println("队列已满，等待消费" + ",SIZE:" + queue.size());
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String s = String.valueOf(System.nanoTime());
queue.add(s);
System.out.println("【生产】" + s + ",SIZE:" + queue.size());
lock.notifyAll();
}
}
}
}
同理消费者线程也是类似，锁和队列也是构造方法传入
1.线程里直接死循环持续消费消息，可以调用remove()方法
2.需要添加一个条件，如果队列已经空了，就不能继续消费了，调用wait()方法等待被其它线程生产了消息之后唤醒
3.消费了消息后，调用notifyAll()方法，唤醒等待的所有线程，直到synchronized全部执行完之后，释放lock锁供其它线程竞争来消费
package com.lihuia.multithreading;
import java.util.Queue;
/**
* Copyright (C), 2018-2019
* FileName: ConsumerThread
* Author: lihui
* Date: 2019-09-09
*/
public class ConsumerThread implements Runnable {
private Object lock;
private Queue<String> queue;
public ConsumerThread(Object lock, Queue<String> queue) {
this.lock = lock;
this.queue = queue;
}
@Override
public void run() {
while (true) {
synchronized (lock) {
while (queue.isEmpty()) {
try {
System.out.println("队列为空，等待生产" + ",SIZE:" + queue.size());
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("【消费】" + queue.remove() + ",SIZE:" + queue.size());
lock.notifyAll();
}
}
}
}
main方法测试类，只需要各自起一个线程，因为死循环不用结束
package com.lihuia.multithreading;
import java.util.LinkedList;
import java.util.Queue;
/**
* Copyright (C), 2018-2019
* FileName: TaskQueueTest
* Author: lihui
* Date: 2019-09-09
*/
public class MainTest {
public static void main(String[] args) {
Object lock = new Object();
Queue<String> queue = new LinkedList<>();
ProducerThread p = new ProducerThread(lock, queue);
ConsumerThread c = new ConsumerThread(lock, queue);
Thread producerThread = new Thread(p);
Thread consumerThread = new Thread(c);
producerThread.start();
consumerThread.start();
}
}
运行结果里截选了一段，可以看到的是当队列为空，下一个就是生产消息的线程；当队列已满，下一个就是消费消息的线程；队列非空未满的情况线程随意，这便是多线程wait()/notify()的作用
队列为空，等待生产,SIZE:0
【生产】457196908372693,SIZE:1
【生产】457196908377523,SIZE:2
【消费】457196908372693,SIZE:1
【消费】457196908377523,SIZE:0
队列为空，等待生产,SIZE:0
【生产】457196908402848,SIZE:1
【生产】457196908408694,SIZE:2
【生产】457196908411841,SIZE:3
【生产】457196908416546,SIZE:4
【生产】457196908427699,SIZE:5
队列已满，等待消费,SIZE:5
【消费】457196908402848,SIZE:4
【消费】457196908408694,SIZE:3
【消费】457196908411841,SIZE:2
【消费】457196908416546,SIZE:1
【消费】457196908427699,SIZE:0
【生产】457196908467660,SIZE:1
【生产】457196908474742,SIZE:2
【消费】457196908467660,SIZE:1
【消费】457196908474742,SIZE:0
队列为空，等待生产,SIZE:0
【生产】457196908506656,SIZE:1
【生产】457196908513924,SIZE:2
【生产】457196908516646,SIZE:3
【生产】457196908520747,SIZE:4
【生产】457196908523427,SIZE:5
【消费】457196908506656,SIZE:4
【消费】457196908513924,SIZE:3
【消费】457196908516646,SIZE:2
【消费】457196908520747,SIZE:1
【消费】457196908523427,SIZE:0
队列为空，等待生产,SIZE:0
【生产】457196908588817,SIZE:1
【生产】457196908595129,SIZE:2
【生产】457196908599816,SIZE:3
【生产】457196908610471,SIZE:4
【生产】457196908615401,SIZE:5
下面就是要研究的wait()方法，调用都放在了while而不是if里，比如在消费者线程里，启动该线程后，假如队列为空，等待生产者先生产消息，然后唤醒消费者消费，好像是一个if就可以搞定，其实不然
首先还是更直观看下wait和notify的流程
然后假如消费者线程里用if而不是while来判断以及执行wait，如下
public void run() {
while (true) {
synchronized (lock) {
if (queue.isEmpty()) {
try {
System.out.println("队列为空，等待生产" + ",SIZE:" + queue.size());
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("【消费】" + queue.remove() + ",SIZE:" + queue.size());
lock.notifyAll();
}
}
}
假如只有一个生产者和一个消费者，队列空了，等待生产，生产好了唤醒消费，是没什么问题的；假如有多个消费者，比如consumer1和consumer2，当queue为空，consumer1里调用了wait等待，consumer2在synchronize处等待，等provider生产了一条消息后，notifyAll然后consumer2抢到了锁，消费了这条消息，这时候queue又空了，consumer2释放了锁之后，consumer1获取了锁，直接从wait()处执行，也不会进行queue.isEmpty()的判断，直接继续执行queue.remove()而报错，因为queue是空的
继续画一个直观的图
问题的关键在于，执行了wait()方法的线程处于阻塞状态，而其它线程调用notifyAll()唤醒该阻塞状态的线程时，该线程是沿着wait()代码处继续往下执行的，因此如果用if的话，这个判断条件已经过了，不管满不满足条件，都会继续往后执行，从而消费了为空的队列；而假如用while，此刻wait()已经在while代码块里面了，都会重新进行一次条件的判断，如果队列为空不满足，那就继续wait()等待好了，如果队列不为空，才继续执行消费
