生产者消费者模型
TIP
这里的生产者消费者模型是最简单的模型:一个生产者、一个消费者、仓库容量 1 。
#monitor 对象版
在 Java 的世界中,所有的对象都可以做 “锁对象” 。注意,这里的 “锁对象” 是广义上的锁对象,并非单指 Lock 对象。用到的单词是 Monitor ,也叫检测对象。
但是对锁(Monitor)对象的使用,有一个特殊要求(其实也是有原因的):在调用 Monitor 对象的 wait、signal 方法的调用必须在同步代码块( synchronized )中。
// 定义两个字符串常量充当锁(monitor)对象
private static final String canRead = "can read";
private static final String canWrite = "can write";
public static void main(String[] args) {
// 消费者线程,执行读操作。从 “仓库” 中取走数据。
Thread reader = new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
synchronized (canRead) {
if (box == null)
canRead.wait(); // 当前线程阻塞在 canRead monitor 对象上 。
}
System.out.printf("%c ", box);
box = null;
synchronized (canWrite) {
canWrite.notify(); // 唤醒阻塞在 canWrite monitor 对象上的任一线程 。
}
}
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
});
// 生产者线程,执行写操作。向 “仓库” 中存放数据。
Thread write = new Thread(() -> {
for (char c = 'a'; c <= 'z'; c++) {
try {
synchronized (canWrite) {
if (box != null)
canWrite.wait(); // 当前线程阻塞在 canWrite monitor 对象上
}
box = c;
synchronized (canRead) {
canRead.notify(); // 唤醒阻塞在 canRead monitor 对象上的任一线程
}
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
});
reader.start();
write.start();
}
1
#条件变量版本
条件(Condition)变量是操作系统原理中的概念。各种操作系统都支持、实现了条件变量。作为虚拟机,JVM 也不例外。
条件变量和上面的锁(monitor)对象一样,都能造成当前线程的阻塞,造成 “当前线程阻塞在 xxx 条件变量上” 的情况,并且,同样也可以做到 “唤醒阻塞在 xxx 条件变量上的线程” 。
条件变量有一个特殊性:它来源于一个锁(Lock)对象。你要通过一个 Lock 对象来获得一个或多个条件变量,并且,你在操作条件变量之前,必须要先获得派生出它的那个 Lock 对象。
public static Lock synchronizedLock = new ReentrantLock(); // 用来“派生”条件变量的锁对象
// 条件(condition)变量来自于锁。
public static Condition canRead = synchronizedLock.newCondition();
public static Condition canWrite = synchronizedLock.newCondition();
public static void main(String[] args) {
// 生产者线程。
Thread writer = new Thread(() -> {
for (char c = 'a'; c <= 'z'; c++) {
try {
synchronizedLock.lock(); // 获得派生出条件变量的那个锁对象。
if (box != null)
canWrite.await(); // 当前线程阻塞在 canWrite 条件变量上
box = c;
canRead.signal(); // 唤醒阻塞在 canRead 条件变量上的线程
synchronizedLock.unlock(); // 释放派生出条件变量的那个锁对象。
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread reader = new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
synchronizedLock.lock(); // 获得派生出条件变量的那个锁对象。
if (box == null)
canRead.await(); // 当前线程阻塞在 canRead 条件变量上
System.out.printf("%c ", box);
box = null;
canWrite.signal(); // 唤醒阻塞在 canWrite 条件变量上的任一线程
synchronizedLock.unlock(); // 释放派生出条件变量的那个锁对象。
}
System.out.println();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
writer.start();
reader.start();
}
1
#信号量版本
信号量(Semaphore)也是操作系统原理中的概念。各种操作系统都支持、实现了条件变量。作为虚拟机,JVM 也不例外。
在使用经验上:信号量(背后的那个数字)代表的是资源数量。
- 生产者:需要的资源是 “坑位” 。 生产过程会导致 “坑位数 - 1” ,但是同时会导致 “商品数 + 1” ;
- 消费者:需要的资源是 “商品” 。 消费过程会导致 “商品数 - 1” ,但是同时会导致 “坑位数 + 1” 。
对信号量做减法,如果不够减(结果为负),会导致当前线程的阻塞;一直阻塞到够减,才会做这个减法,然后继续执行。
public static Semaphore productNum = new Semaphore(0); // 初始状态,商品数为 0
public static Semaphore pitNum = new Semaphore(1); // 初始状态,坑位数为 1
public static void main(String[] args) {
Thread reader = new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
productNum.acquire(); // productNum - 1
System.out.printf("%c ", box);
pitNum.release(1); // pitNum + 1
}
System.out.println();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread write = new Thread(() -> {
for (char c = 'a'; c <= 'z'; c++) {
try {
pitNum.acquire(); // pitNum - 1
box = c;
productNum.release(1); // productNum + 1
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
reader.start();
write.start();
}