一、概念解读
- synchronized：同步锁，可修饰方法、代码块；
- wait：使当前线程进入等待状态，直到锁定对象被唤醒；可指定最大等待时间，自动唤醒；
- notify：随机唤醒当前对象上等待的单个线程；
- notifyAll：唤醒当前对象上等待的所有线程；
二、sleep?
- sleep不会释放锁，而wait会；
- wait可不指定时间；
- sleep存在Thread中，而wait存在Object中；
三、wait、notify使用场景
synchronized是同步锁，目的是在同步代码块中获取锁，其他线程没持有锁则不能访问，从而保证共享数据线程安全。wait是释放当前对象锁，并且使得当前线程等待，notify（notifyAll）是唤醒对象上等待获取锁的线程，所以wait、notify、notifyAll都必须写在synchronized同步代码区中，否则出现IllegalMonitorStateException异常。
假设一个消费线程，消费操作（减库存）必须是同步的，然后对库存加锁，那么这里就有判断，如果库存不大于0，释放锁，使当前线程等待，知道生产线程（加库存）唤醒，可能很多人这样写：
synchronized(库存){
if(库存为空){
库存.wait();
}
// 执行消费，减库存
}
咋的一看这样没问题，消费之前判断库存大小，空则释放锁，等待被唤醒，但问题来了，不只是生产线程能够唤醒，可能在其他地方库存被唤醒，但是实际库存并没有变化，就会导致库存大小为负数问题。所以，这里要改为：
synchronized(库存){
while(库存为空){
库存.wait();
}
// 执行消费，减库存
}
所以wait方法一定是在循环中调用，而不是if语句。
注：有说明notify也是一定要在循环中调用，目前还不知缘由，暂且搁着(*･ω-q)。
四、实践见真理
思路分析：
- 模拟库存，库存为空时消费线程等待，库存满了时生产线程等待；
- 执行消费操作后唤醒在库存对象上等待的生产线程，（如果有生产线程等待则可以唤醒继续生产）；
- 执行生产操作后唤醒在库存对象上等待的消费线程，（如果有消费线程等待则可以唤醒继续消费）；
生产者，将LinkedList比作库存，用一个循环体生产线程：
package com.cjt.concurrent;
import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.TimeUnit;
class Producer implements Runnable {
private final LinkedList<Integer> list;
Producer(LinkedList<Integer> list) {
this.list = list;
}
@Override
public void run() {
while (true) {
synchronized (list) {
while (list.size() >= 3) {
System.out.println("库存已满，等待消费后继续生产");
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("开始生产");
list.add(new Random().nextInt());
list.notifyAll();
}
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
消费者，假设一个消费线程减少一个库存：
package com.cjt.concurrent;
import java.util.LinkedList;
final class Consumer implements Runnable {
private final LinkedList<Integer> list;
Consumer(LinkedList<Integer> list){
this.list = list;
}
@Override
public void run() {
synchronized(list){
while (list.isEmpty()) {
System.out.println("库存为空，等待生产");
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("消费");
list.remove();
list.notifyAll();
}
}
}
主程序，首先开启生产者线程，创建两个消费者线程：
package com.cjt.concurrent;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
public class Test {
private static LinkedList<Integer> list = new LinkedList<>();
public static void main(String[] args) throws InterruptedException {
new Thread(new Producer(list)).start();
TimeUnit.SECONDS.sleep(1);
new Thread(new Consumer(list)).start();
TimeUnit.SECONDS.sleep(1);
new Thread(new Consumer(list)).start();
}
}
TimeUnit真的很好用，实现线程睡眠可替代Thread.sleep()。
运行主程序观察控制台可发现：
开始生产
开始生产
开始生产
库存已满，等待消费后继续生产
消费
开始生产
库存已满，等待消费后继续生产
消费
开始生产
库存已满，等待消费后继续生产
说明库存满后生产者线程wait，然后消费者线程开始消费，消费完成即notify生产者线程继续生产；
可以更换生产者、消费者线程调用顺序：
new Thread(new Consumer(list)).start();
TimeUnit.SECONDS.sleep(1);
new Thread(new Consumer(list)).start();
TimeUnit.SECONDS.sleep(1);
new Thread(new Producer(list)).start();
再次观测控制台结果：
库存为空，等待生产
库存为空，等待生产
开始生产
开始生产
开始生产
库存已满，等待消费后继续生产
消费
消费
开始生产
开始生产
库存已满，等待消费后继续生产
在开始两个消费者启用没有库存导致消费者线程wait，待生产者线程生产完毕后notify消费者开始消费，消费后即通知生产者开始生产；
五、举个例子
使用wait、notify实现两个线程交替相加；
package com.cjt;
import java.util.concurrent.atomic.LongAdder;
public class App {
public static void main(String[] args) {
LongAdder count = new LongAdder();
new Thread(() -> {
while (true) {
synchronized (count) {
while (count.intValue() % 2 == 0) {
try {
count.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count.increment();
System.out.println(Thread.currentThread().getName() + ":" + count.intValue());
count.notify();
}
}
}).start();
new Thread(() -> {
while (true) {
synchronized (count) {
while (count.intValue() % 2 == 1) {
try {
count.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count.increment();
System.out.println(Thread.currentThread().getName() + ":" + count.intValue());
count.notify();
}
}
}).start();
}
}
运行日志：
Thread-1:1
Thread-0:2
Thread-1:3
Thread-0:4
...
使用LongAdder作为共享变量，一个线程判断为奇数加1并notify该共享变量上等待的线程，为偶数则wait等待，另一个线程刚好相反；
网友评论