前言
生產者-消費者模式是一個十分經典的多線程併發協作的模式，弄懂生產者-消費者問題能夠讓我們對併發編程的理解加深。所謂生產者-消費者問題，實際上主要是包含了兩類線程，一種是生產者線程用於生產數據，另一種是消費者線程用於消費數據，爲了解耦生產者和消費者的關係，通常會有一個共享的數據區域，就像是一個倉庫，生產者生產數據之後直接放置在共享數據區中，並不需要關心消費者的行爲；而消費者只需要從共享數據區中去獲取數據，就不再需要關心生產者的行爲。但是，這個共享數據區域中應該具備這樣的線程間併發協作的功能：
- 如果共享數據區已滿的話，阻塞生產者繼續生產數據放置入內；
- 如果共享數據區爲空的話，阻塞消費者繼續消費數據；
在實現生產者消費者問題時，可以採用三種方式：
使用Object的wait/notify的消息通知機制；
使用Lock的Condition的await/signal的消息通知機制；
使用BlockingQueue實現。
本文主要將這三種實現方式進行總結歸納。
wait/notify的消息通知機制
預備知識
Java 中，可以通過配合調用 Object 對象的 wait() 方法和 notify()方法或 notifyAll() 方法來實現線程間的通信。在線程中調用 wait() 方法，將阻塞當前線程，直至等到其他線程調用了 notify() 方法或 notifyAll() 方法進行通知之後，當前線程才能從wait()方法出返回，繼續執行下面的操作。
-
wait
該方法用來將當前線程置入休眠狀態，直到接到通知或被中斷爲止。在調用 wait()之前，線程必須要獲得該對象的對象監視器鎖，即只能在同步方法或同步塊中調用 wait()方法。調用wait()方法之後，當前線程會釋放鎖。如果調用wait()方法時，線程並未獲取到鎖的話，則會拋出IllegalMonitorStateException異常，這是一個RuntimeException。如果再次獲取到鎖的話，當前線程才能從wait()方法處成功返回。
-
notify
該方法也要在同步方法或同步塊中調用，即在調用前，線程也必須要獲得該對象的對象級別鎖，如果調用 notify()時沒有持有適當的鎖，也會拋出 IllegalMonitorStateException。
該方法任意從WAITTING狀態的線程中挑選一個進行通知，使得調用wait()方法的線程從等待隊列移入到同步隊列中，等待有機會再一次獲取到鎖，從而使得調用wait()方法的線程能夠從wait()方法處退出。調用notify後，當前線程不會馬上釋放該對象鎖，要等到程序退出同步塊後，當前線程纔會釋放鎖。 notifyAll
該方法與 notify ()方法的工作方式相同，重要的一點差異是：
notifyAll 使所有原來在該對象上 wait 的線程統統退出WAITTING狀態，使得他們全部從等待隊列中移入到同步隊列中去，等待下一次能夠有機會獲取到對象監視器鎖。
wait/notify消息通知潛在的一些問題
notify過早通知
notify 通知的遺漏很容易理解，即 threadA 還沒開始 wait 的時候，threadB 已經 notify 了，這樣，threadB 通知是沒有任何響應的，當 threadB 退出 synchronized 代碼塊後，threadA 再開始 wait，便會一直阻塞等待，直到被別的線程打斷。比如在下面的示例代碼中，就模擬出notify早期通知帶來的問題：
public class EarlyNotifyDemo1 {
private static String lockObject = "";
public static void main(String[] args) {
WaitThread waitThread = new WaitThread(lockObject);
NotifyThread notifyThread = new NotifyThread(lockObject);
notifyThread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
waitThread.start();
}
static class WaitThread extends Thread {
private String lock;
public WaitThread(String lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
try {
System.out.println(Thread.currentThread().getName() + " 進去代碼塊");
System.out.println(Thread.currentThread().getName() + " 開始wait");
lock.wait();
System.out.println(Thread.currentThread().getName() + " 結束wait");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class NotifyThread extends Thread {
private String lock;
public NotifyThread(String lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " 進去代碼塊");
System.out.println(Thread.currentThread().getName() + " 開始notify");
lock.notify();
System.out.println(Thread.currentThread().getName() + " 結束開始notify");
}
}
}
}
輸出結果
Thread-1 進去代碼塊
Thread-1 開始notify
Thread-1 結束開始notify
Thread-0 進去代碼塊
Thread-0 開始wait
示例中開啓了兩個線程，一個是WaitThread，另一個是NotifyThread。NotifyThread會先啓動，先調用notify方法。然後WaitThread線程才啓動，調用wait方法，但是由於通知過了，wait方法就無法再獲取到相應的通知，因此WaitThread會一直在wait方法出阻塞，這種現象就是通知過早的現象。針對這種現象，解決方法，一般是添加一個狀態標誌，讓waitThread調用wait方法前先判斷狀態是否已經改變了沒，如果通知早已發出的話，WaitThread就不再去wait。對上面的代碼進行更正：
public class EarlyNotifyDemo2 {
private static String lockObject = "";
private static boolean isWait = true;
public static void main(String[] args) {
WaitThread waitThread = new WaitThread(lockObject);
NotifyThread notifyThread = new NotifyThread(lockObject);
notifyThread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
waitThread.start();
}
static class WaitThread extends Thread {
private String lock;
public WaitThread(String lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
try {
while (isWait) {
System.out.println(Thread.currentThread().getName() + " 進去代碼塊");
System.out.println(Thread.currentThread().getName() + " 開始wait");
lock.wait();
System.out.println(Thread.currentThread().getName() + " 結束wait");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class NotifyThread extends Thread {
private String lock;
public NotifyThread(String lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " 進去代碼塊");
System.out.println(Thread.currentThread().getName() + " 開始notify");
lock.notifyAll();
isWait = false;
System.out.println(Thread.currentThread().getName() + " 結束開始notify");
}
}
}
}
這段代碼只是增加了一個isWait狀態變量，NotifyThread調用notify方法後會對狀態變量進行更新，在WaitThread中調用wait方法之前會先對狀態變量進行判斷，在該示例中，調用notify後將狀態變量isWait改變爲false，因此，在WaitThread中while對isWait判斷後就不會執行wait方法，從而避免了Notify過早通知造成遺漏的情況。
總結：在使用線程的等待/通知機制時，一般都要配合一個 boolean 變量值（或者其他能夠判斷真假的條件），在 notify 之前改變該 boolean 變量的值，讓 wait 返回後能夠退出 while 循環（一般都要在 wait 方法外圍加一層 while 循環，以防止早期通知），或在通知被遺漏後，不會被阻塞在 wait 方法處。這樣便保證了程序的正確性
等待wait的條件發生變化
如果線程在等待時接受到了通知，但是之後等待的條件發生了變化，並沒有再次對等待條件進行判斷，也會導致程序出現錯誤。
下面用一個例子來說明這種情況
public class ConditionChangeDemo1 {
private static List<String> lockObject = new ArrayList();
public static void main(String[] args) {
Consumer consumer1 = new Consumer(lockObject);
Consumer consumer2 = new Consumer(lockObject);
Productor productor = new Productor(lockObject);
consumer1.start();
consumer2.start();
productor.start();
}
static class Consumer extends Thread {
private List<String> lock;
public Consumer(List lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
try {
//這裏使用if的話，就會存在wait條件變化造成程序錯誤的問題
if (lock.isEmpty()) {
System.out.println(Thread.currentThread().getName() + " list爲空");
System.out.println(Thread.currentThread().getName() + " 調用wait方法");
lock.wait();
System.out.println(Thread.currentThread().getName() + " wait方法結束");
}
String element = lock.remove(0);
System.out.println(Thread.currentThread().getName() + " 取出第一個元素爲：" + element);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class Productor extends Thread {
private List<String> lock;
public Productor(List lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " 開始添加元素");
lock.add(Thread.currentThread().getName());
lock.notifyAll();
}
}
}
}
輸出結果
Thread-0 list爲空
Thread-0 調用wait方法
Thread-2 開始添加元素
Thread-1 取出第一個元素爲：Thread-2
Thread-0 wait方法結束
Exception in thread "Thread-0" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
異常原因分析：在這個例子中一共開啓了3個線程，Consumer1,Consumer2以及Productor。首先Consumer1調用了wait方法後，線程處於了WAITTING狀態，並且將對象鎖釋放出來。因此，Consumer2能夠獲取對象鎖，從而進入到同步代塊中，當執行到wait方法時，同樣的也會釋放對象鎖。因此，productor能夠獲取到對象鎖，進入到同步代碼塊中，向list中插入數據後，通過notifyAll方法通知處於WAITING狀態的Consumer1和Consumer2線程。consumer1得到對象鎖後，從wait方法出退出，刪除了一個元素讓List爲空，方法執行結束，退出同步塊，釋放掉對象鎖。這個時候Consumer2獲取到對象鎖後，從wait方法退出，繼續往下執行，這個時候Consumer2再執行lock.remove(0);就會出錯，因爲List由於Consumer1刪除一個元素之後已經爲空了。
解決方案：通過上面的分析，可以看出Consumer2報異常是因爲線程從wait方法退出之後沒有再次對wait條件進行判斷，因此，此時的wait條件已經發生了變化。解決辦法就是，在wait退出之後再對條件進行判斷即可。
public class ConditionChangeDemo2 {
private static List<String> lockObject = new ArrayList();
public static void main(String[] args) {
Consumer consumer1 = new Consumer(lockObject);
Consumer consumer2 = new Consumer(lockObject);
Productor productor = new Productor(lockObject);
consumer1.start();
consumer2.start();
productor.start();
}
static class Consumer extends Thread {
private List<String> lock;
public Consumer(List lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
try {
//這裏使用if的話，就會存在wait條件變化造成程序錯誤的問題
while (lock.isEmpty()) {
System.out.println(Thread.currentThread().getName() + " list爲空");
System.out.println(Thread.currentThread().getName() + " 調用wait方法");
lock.wait();
System.out.println(Thread.currentThread().getName() + " wait方法結束");
}
String element = lock.remove(0);
System.out.println(Thread.currentThread().getName() + " 取出第一個元素爲：" + element);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class Productor extends Thread {
private List<String> lock;
public Productor(List lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " 開始添加元素");
lock.add(Thread.currentThread().getName());
lock.notifyAll();
}
}
}
}
輸出結果
Thread-0 list爲空
Thread-0 調用wait方法
Thread-2 開始添加元素
Thread-1 取出第一個元素爲：Thread-2
Thread-0 wait方法結束
Thread-0 list爲空
Thread-0 調用wait方法
上面的代碼與之前的代碼僅僅只是將 wait 外圍的 if 語句改爲 while 循環即可，這樣當 list 爲空時，線程便會繼續等待，而不會繼續去執行刪除 list 中元素的代碼。
總結：在使用線程的等待/通知機制時，一般都要在 while 循環中調用 wait()方法，因此配合使用一個 boolean 變量（或其他能判斷真假的條件，如本文中的 list.isEmpty()），滿足 while 循環的條件時，進入 while 循環，執行 wait()方法，不滿足 while 循環的條件時，跳出循環，執行後面的代碼。
假死狀態
現象：如果是多消費者和多生產者情況，如果使用notify方法可能會出現“假死”的情況，即喚醒的是同類線程。
原因分析：假設當前多個生產者線程會調用wait方法阻塞等待，當其中的生產者線程獲取到對象鎖之後使用notify通知處於WAITTING狀態的線程，如果喚醒的仍然是生產者線程，就會造成所有的生產者線程都處於等待狀態。
解決辦法：將notify方法替換成notifyAll方法，如果使用的是lock的話，就將signal方法替換成signalAll方法。
總結
在Object提供的消息通知機制應該遵循如下這些條件：
- 永遠在while循環中對條件進行判斷而不是if語句中進行wait條件的判斷；
- 使用NotifyAll而不是使用notify。
基本的使用範式如下：
// The standard idiom for calling the wait method in Java
synchronized (sharedObject) {
while (condition) {
sharedObject.wait();
// (Releases lock, and reacquires on wakeup)
}
// do action based upon condition e.g. take or put into queue
}
wait/notifyAll實現生產者-消費者
利用wait/notifyAll實現生產者和消費者代碼如下：
public class ProductorConsumerDemo1 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
ExecutorService service = Executors.newFixedThreadPool(15);
for (int i = 0; i < 5; i++) {
service.submit(new Productor(linkedList, 8));
}
for (int i = 0; i < 10; i++) {
service.submit(new Consumer(linkedList));
}
}
static class Productor implements Runnable {
private List<Integer> list;
private int maxLength;
public Productor(List list, int maxLength) {
this.list = list;
this.maxLength = maxLength;
}
@Override
public void run() {
while (true) {
synchronized (list) {
try {
while (list.size() == maxLength) {
System.out.println("生產者" + Thread.currentThread().getName() + " list以達到最大容量，進行wait");
list.wait();
System.out.println("生產者" + Thread.currentThread().getName() + " 退出wait");
}
Random random = new Random();
int i = random.nextInt();
System.out.println("生產者" + Thread.currentThread().getName() + " 生產數據" + i);
list.add(i);
list.notifyAll();
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
static class Consumer implements Runnable {
private List<Integer> list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
while (true) {
synchronized (list) {
try {
while (list.isEmpty()) {
System.out.println("消費者" + Thread.currentThread().getName() + " list爲空，進行wait");
list.wait();
System.out.println("消費者" + Thread.currentThread().getName() + " 退出wait");
}
Integer element = list.remove(0);
System.out.println("消費者" + Thread.currentThread().getName() + " 消費數據：" + element);
list.notifyAll();
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
輸出結果
生產者pool-1-thread-2 生產數據-703210513
生產者pool-1-thread-2 生產數據-1025434820
生產者pool-1-thread-2 生產數據70070412
生產者pool-1-thread-2 生產數據-598504371
生產者pool-1-thread-2 生產數據-716978999
生產者pool-1-thread-2 生產數據-1175198461
生產者pool-1-thread-2 生產數據-1212912406
生產者pool-1-thread-2 生產數據-332467186
生產者pool-1-thread-2 list以達到最大容量，進行wait
消費者pool-1-thread-15 消費數據：-703210513
消費者pool-1-thread-15 消費數據：-1025434820
消費者pool-1-thread-15 消費數據：70070412
消費者pool-1-thread-15 消費數據：-598504371
消費者pool-1-thread-15 消費數據：-716978999
消費者pool-1-thread-15 消費數據：-1175198461
消費者pool-1-thread-15 消費數據：-1212912406
消費者pool-1-thread-15 消費數據：-332467186
消費者pool-1-thread-15 list爲空，進行wait
消費者pool-1-thread-14 list爲空，進行wait
消費者pool-1-thread-13 list爲空，進行wait
消費者pool-1-thread-11 list爲空，進行wait
消費者pool-1-thread-12 list爲空，進行wait
消費者pool-1-thread-10 list爲空，進行wait
消費者pool-1-thread-9 list爲空，進行wait
消費者pool-1-thread-8 list爲空，進行wait
消費者pool-1-thread-7 list爲空，進行wait
消費者pool-1-thread-6 list爲空，進行wait
生產者pool-1-thread-5 生產數據84590545
生產者pool-1-thread-5 生產數據-1631754695
使用Lock中Condition的await/signalAll實現生產者-消費者
參照Object的wait和notify/notifyAll方法，Condition也提供了同樣的方法：
針對wait方法
void await() throws InterruptedException：當前線程進入等待狀態，如果其他線程調用condition的signal或者signalAll方法並且當前線程獲取Lock從await方法返回，如果在等待狀態中被中斷會拋出被中斷異常；
long awaitNanos(long nanosTimeout)：當前線程進入等待狀態直到被通知，中斷或者超時；
boolean await(long time, TimeUnit unit)throws InterruptedException：同第二種，支持自定義時間單位
boolean awaitUntil(Date deadline) throws InterruptedException：當前線程進入等待狀態直到被通知，中斷或者到了某個時間
針對notify方法
void signal()：喚醒一個等待在condition上的線程，將該線程從等待隊列中轉移到同步隊列中，如果在同步隊列中能夠競爭到Lock則可以從等待方法中返回。
void signalAll()：與signal的區別在於能夠喚醒所有等待在condition上的線程
也就是說wait—>await，notify---->Signal。
如果採用lock中Conditon的消息通知原理來實現生產者-消費者問題，原理同使用wait/notifyAll一樣。直接上代碼：
public class ProductorConsumerDemo2 {
private static ReentrantLock lock = new ReentrantLock();
private static Condition full = lock.newCondition();
private static Condition empty = lock.newCondition();
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
ExecutorService service = Executors.newFixedThreadPool(15);
for (int i = 0; i < 5; i++) {
service.submit(new Productor(linkedList, 8, lock));
}
for (int i = 0; i < 10; i++) {
service.submit(new Consumer(linkedList, lock));
}
}
static class Productor implements Runnable {
private List<Integer> list;
private int maxLength;
private Lock lock;
public Productor(List list, int maxLength, Lock lock) {
this.list = list;
this.maxLength = maxLength;
this.lock = lock;
}
@Override
public void run() {
while (true) {
lock.lock();
try {
while (list.size() == maxLength) {
System.out.println("生產者" + Thread.currentThread().getName() + " list以達到最大容量，進行wait");
full.await();
System.out.println("生產者" + Thread.currentThread().getName() + " 退出wait");
}
Random random = new Random();
int i = random.nextInt();
System.out.println("生產者" + Thread.currentThread().getName() + " 生產數據" + i);
list.add(i);
empty.signalAll();
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
static class Consumer implements Runnable {
private List<Integer> list;
private Lock lock;
public Consumer(List list, Lock lock) {
this.list = list;
this.lock = lock;
}
@Override
public void run() {
while (true) {
lock.lock();
try {
while (list.isEmpty()) {
System.out.println("消費者" + Thread.currentThread().getName() + " list爲空，進行wait");
empty.await();
System.out.println("消費者" + Thread.currentThread().getName() + " 退出wait");
}
Integer element = list.remove(0);
System.out.println("消費者" + Thread.currentThread().getName() + " 消費數據：" + element);
full.signalAll();
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
}
輸出結果
生產者pool-1-thread-1 生產數據-1633842993
生產者pool-1-thread-1 生產數據1337251950
生產者pool-1-thread-1 生產數據1310879631
生產者pool-1-thread-1 生產數據-214297115
生產者pool-1-thread-1 生產數據738937512
生產者pool-1-thread-1 生產數據13060041
生產者pool-1-thread-1 生產數據-957049554
生產者pool-1-thread-1 生產數據-1062017880
生產者pool-1-thread-1 list以達到最大容量，進行wait
生產者pool-1-thread-2 list以達到最大容量，進行wait
生產者pool-1-thread-3 list以達到最大容量，進行wait
生產者pool-1-thread-4 list以達到最大容量，進行wait
生產者pool-1-thread-5 list以達到最大容量，進行wait
消費者pool-1-thread-6 消費數據：-1633842993
消費者pool-1-thread-6 消費數據：1337251950
消費者pool-1-thread-6 消費數據：1310879631
消費者pool-1-thread-6 消費數據：-214297115
消費者pool-1-thread-6 消費數據：738937512
消費者pool-1-thread-6 消費數據：13060041
消費者pool-1-thread-6 消費數據：-957049554
消費者pool-1-thread-6 消費數據：-1062017880
消費者pool-1-thread-6 list爲空，進行wait
消費者pool-1-thread-7 list爲空，進行wait
消費者pool-1-thread-8 list爲空，進行wait
消費者pool-1-thread-9 list爲空，進行wait
消費者pool-1-thread-10 list爲空，進行wait
消費者pool-1-thread-11 list爲空，進行wait
消費者pool-1-thread-12 list爲空，進行wait
消費者pool-1-thread-13 list爲空，進行wait
消費者pool-1-thread-14 list爲空，進行wait
消費者pool-1-thread-15 list爲空，進行wait
生產者pool-1-thread-1 退出wait
生產者pool-1-thread-1 生產數據1949864858
生產者pool-1-thread-1 生產數據-1693880970
使用BlockingQueue實現生產者-消費者
由於BlockingQueue內部實現就附加了兩個阻塞操作。即當隊列已滿時，阻塞向隊列中插入數據的線程，直至隊列中未滿；當隊列爲空時，阻塞從隊列中獲取數據的線程，直至隊列非空時爲止。可以利用BlockingQueue實現生產者-消費者爲題，阻塞隊列完全可以充當共享數據區域，就可以很好的完成生產者和消費者線程之間的協作。
public class ProductorConsumerDmoe3 {
private static LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(15);
for (int i = 0; i < 5; i++) {
service.submit(new Productor(queue));
}
for (int i = 0; i < 10; i++) {
service.submit(new Consumer(queue));
}
}
static class Productor implements Runnable {
private BlockingQueue queue;
public Productor(BlockingQueue queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (true) {
Random random = new Random();
int i = random.nextInt();
System.out.println("生產者" + Thread.currentThread().getName() + "生產數據" + i);
queue.put(i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class Consumer implements Runnable {
private BlockingQueue queue;
public Consumer(BlockingQueue queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (true) {
Integer element = (Integer) queue.take();
System.out.println("消費者" + Thread.currentThread().getName() + "正在消費數據" + element);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
輸出結果
生產者pool-1-thread-2生產數據-1056722868
生產者pool-1-thread-1生產數據-1217947426
生產者pool-1-thread-3生產數據590686437
生產者pool-1-thread-4生產數據1782376429
生產者pool-1-thread-5生產數據1558897279
消費者pool-1-thread-6正在消費數據-1056722868
消費者pool-1-thread-7正在消費數據-1217947426
消費者pool-1-thread-8正在消費數據590686437
消費者pool-1-thread-9正在消費數據1782376429
消費者pool-1-thread-10正在消費數據1558897279
生產者pool-1-thread-4生產數據1977644261
生產者pool-1-thread-3生產數據182370155
消費者pool-1-thread-11正在消費數據1977644261
生產者pool-1-thread-2生產數據949821636
生產者pool-1-thread-5生產數據1931032717
消費者pool-1-thread-13正在消費數據949821636
生產者pool-1-thread-1生產數據873417555
消費者pool-1-thread-14正在消費數據1931032717
消費者pool-1-thread-12正在消費數據182370155
消費者pool-1-thread-15正在消費數據873417555
可以看出，使用BlockingQueue來實現生產者-消費者很簡潔，這正是利用了BlockingQueue插入和獲取數據附加阻塞操作的特性。
關於生產者-消費者實現的三種方式，到這裏就全部總結出來，如果覺得不錯的話，請點贊轉發，也算是給我的鼓勵，在此表示感謝！歡迎關注公衆號：前程有光，領取一線大廠Java面試題總結+各知識點學習思維導+一份300頁pdf文檔的Java核心知識點總結！