用阻塞佇列實現一個生產者消費者模型？synchronized和lock有什麼區別？

y浴血發表於2021-07-10

佇列模型synchronized

多執行緒當中的阻塞佇列

主要實現類有

ArrayBlockingQueue是一個基於陣列結構的有界阻塞佇列，此佇列按FIFO原則對元素進行排序
LinkedBlockingQueue是一個基於連結串列結構的阻塞佇列，此佇列按FIFO排序元素，吞吐量通常要高於ArrayBlockingQueue
SynchronousQueue是一個不儲存元素的阻塞佇列，單個插入操作必須等到另一個執行緒呼叫移除操作，否則插入操作一直處於阻塞狀態

1. 阻塞佇列概念

阻塞佇列通俗來說，是一個佇列，而一個阻塞佇列再資料結構中所起的作用大致如下圖

執行緒1往阻塞佇列中新增元素，而執行緒2從阻塞佇列中移除元素

當阻塞佇列是空時，從佇列中獲取元素的操作會被阻塞
當阻塞佇列是滿時，從佇列中新增元素的操作會被阻塞

試圖從空的阻塞佇列中獲取元素的執行緒將會被阻塞，直到其他的執行緒向空的佇列插入新的元素。
試圖向已滿的阻塞佇列中新增新元素的執行緒同樣會被阻塞，直到其他的執行緒從列中移除一個或者多個元素或者完全清空佇列後使佇列重新變得空閒起來並後續新增

很像生產者消費者模型！

2. 為什麼要用阻塞佇列？好處是什麼？

在多執行緒領域:所謂阻塞，在某些情況下會掛起執行緒，一旦滿足條件，被掛起的執行緒又會自動被喚醒
為什麼需要BlockingQueue？

答：好處是我們不需要關心什麼時候需要阻塞執行緒，什麼時候需要喚醒執行緒，因為這一切BlockingQueue都給你一手包辦了
在concurrent包釋出以前，在多執行緒環境下，我們每個程式設計師都必須自己控制這些細節，尤其還要兼顧效率和執行緒安全，而這會給我們程式帶來不小的複雜度
阻塞佇列圖示：

3. BlockingQueue的核心方法

方法型別	丟擲異常	特殊值	阻塞	超時
插入	add(e)	offer(e)	put(e)	offer(e,time,unit)
移除	remove()	poll()	take	poll(time,unit)
檢查	element()	peek()	不可用	不可用

可以看到，對於不同的方法型別，內部對應插入移除以及檢查方法對應的api都不同，所以，想要對不同的對列操作時候，需要考慮是否需要丟擲異常？執行緒是否需要阻塞等，這樣對應不同的方法才能達到事半功倍的效果

參照原始碼

對上述方法型別做描述：

方法型別	描述
丟擲異常	當阻塞佇列滿時，再往佇列中add會拋`IllegalStateException: Queue full` 當阻塞佇列空時，在網佇列裡remove會拋 `NoSuchElementException`(這兩個都是異常)
特殊值	插入方法，成功true失敗false 移除方法，成功返回出佇列的元素，佇列裡沒有就返回null
阻塞	當阻塞佇列滿時，生產者執行緒繼續往佇列裡put元素，佇列會一直阻塞執行緒直到put資料或響應中斷退出當阻塞佇列空時，消費者執行緒試圖從佇列take元素，佇列會一直阻塞消費者執行緒直到佇列可用
超時退出	當阻塞佇列滿時，佇列會阻塞生產者執行緒一定時間超過限時後生產者執行緒會退出

4. 種類分析

4.1 介面檢視

我們知道，阻塞佇列是BlockingQueue，我們開啟Diagram圖檢視類之間的關係可得

Queue是繼承了Queue的介面，同時Queue介面又繼承了Collection介面，那麼BlockingQueue作為介面，那麼一定會有實現類，不同實現類使用不同資料結構實現，完成的操作也不相同，我們這裡列出BlockingQueue的7個實現類，分別為：

ArrayBlockingQueue:由陣列結構組成的有界阻塞佇列
LinkedBlockingQueue:由連結串列結構組成的有界(但大小預設值為 Integer.MAX_VALUE )阻塞佇列
PriorityBlockingQueue:支援優先順序排序的無界阻塞佇列
DelayQueue:使用優先順序佇列實現的延遲無界阻塞佇列
SychronousQueue:不儲存元素的阻塞佇列，也即單個元素的佇列
LinkedTransferQueue:由連結串列結構組成的無界阻塞佇列
LinkedBlockingDeque:由雙向連結串列結構組成的雙向阻塞佇列。

我們常用的實現類，在上面已經用重點符號表示了，ArrayBlockingQueue類似我們常用的ArrayList，底層資料結構是陣列組成的佇列，LinkedBlockingQueue就類似我們常用的LinkedList，底層資料結構是連結串列組成的佇列，這裡要注意LinkedBlockingDeque，那麼Deque的介面繼承關係如下所示：

對於我們常用的實現類，我們可以發現SychronousQueue我們不常用也不瞭解，什麼是單個元素的佇列？那麼我們下面用程式碼實現一下：

4.2 SychronousQueue

概念：SynchronousQueue沒有容量，與其他BlockingQueue不同，SychronousQueue是一個不儲存元素的BlockingQueue，每一個put操作必須要等待一個take操作，否則不能繼續新增元素，反之亦然

程式碼例項：

package com.yuxue.juc.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;



public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue blockingQueue = new SynchronousQueue<>();

        //AAA執行緒主要用來對阻塞佇列進行put操作
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "put 1");
                blockingQueue.put(1);
                System.out.println(Thread.currentThread().getName() + "\t" + "put 2");
                blockingQueue.put(2);
                System.out.println(Thread.currentThread().getName() + "\t" + "put 3");
                blockingQueue.put(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        //BBB執行緒主要從阻塞佇列當中先操作自己的事務，休息5秒，之後拿值
        new Thread(()->{
            try {
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName()+"\t take:"+blockingQueue.take());
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName()+"\t take:"+blockingQueue.take());
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName()+"\t take:"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"BBB").start();
    }
}

程式碼結果為：

AAA	put 1
//經過5秒
BBB	 take:1
AAA	put 2
//經過5秒
BBB	 take:2
AAA	put 3
//經過5秒
BBB	 take:3

5. 用在什麼地方？

講了這麼多BlockingQueue的優點，那麼阻塞佇列一般用在哪裡？

生產者消費者模式

5.1 傳統版生產者消費者模式

package com.yuxue.juc.queue;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//共享資源類
class Share1Data{
    //內部共享變數
    private volatile int num = 0;
    //鎖
    private Lock lock = new ReentrantLock();
    //condition進行通知
    private Condition condition = lock.newCondition();

    //內部對num進行自增的方法
    public void increment() {
        lock.lock();
        try {
            //迴圈判斷
            while (num != 0) {
                condition.await();
            }
            //操作
            num++;
            System.out.println(Thread.currentThread().getName() + "\t" + num);
            //通知
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //內部對num進行自減的方法
    public void decrement() {
        lock.lock();
        try {
            //迴圈判斷
            while (num == 0) {
                condition.await();
            }
            //操作
            num--;
            System.out.println(Thread.currentThread().getName() + "\t" + num);
            //通知
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class TraditionalProCons {
    public static void main(String[] args) {

        Share1Data dataShare = new Share1Data();

        //10個執行緒進行num增加操作，對應生產者
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                dataShare.increment();
            }, "Productor" + i).start();
        }

        //10個執行緒進行num減少操作，對應消費者
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                dataShare.decrement();
            }, "Consumer" + i).start();
        }
    }
}

執行結果為：

Productor0	1
Consumer0	0
Productor1	1
Consumer1	0
Productor3	1
Consumer2	0
Productor5	1
Consumer3	0
Productor7	1
Consumer4	0
Productor8	1
Consumer5	0
Productor2	1
Consumer6	0
Productor9	1
Consumer7	0
Productor4	1
Consumer8	0
Productor6	1
Consumer9	0

可以看到對共享變數進行增加或者減少操作的時候需要進行通知，同時對內部變數進行volatile保證變數的可見性以及禁止指令重排，可以更好地對生產者消費者模型當中操作的保證

5.2 阻塞佇列版生產者消費者模式

package com.yuxue.juc.queue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

class ShareData {
    //標誌位，true表示預設開啟生產者以及消費者
    private volatile boolean flag = true;
    //利用AtomicInteger類保證變數的原子性
    private AtomicInteger atomicInteger = new AtomicInteger();
    //建一個介面
    BlockingQueue<String> blockingQueue = null;

    //傳遞介面，主方法傳遞實際實現的類，可以實現程式碼複用
    //程式設計時儘量傳介面而不是傳類
    public ShareData(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
        System.out.println(blockingQueue.getClass().getName());
    }

    //自己的生產者程式碼
    public void myIncrement() throws InterruptedException {
        String data = null;
        boolean retValue = false;

        //當開啟時
        while (flag) {
            data = atomicInteger.getAndIncrement() + "";
            //2s內新增成功返回true
            retValue = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "\t" + "插入" + data + "阻塞佇列成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t" + "插入" + data + "阻塞佇列失敗");
            }
            Thread.sleep(1000);
        }

        //當結束時，輸出一下表示已經結束了
        System.out.println(Thread.currentThread().getName() + "\t大老闆叫停了， flag=false，生產結束");
    }

    //自己的消費者程式碼
    public void myDecrement() throws InterruptedException {
        String result = null;
        //當開啟時
        while (flag) {
            //2s內移除成功返回true
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            //內部判斷，如果移除的是null，或者移除失敗
            if (null == result || result.equalsIgnoreCase("")) {
                //讓工作停止
                flag = false;
                System.out.println(Thread.currentThread().getName() + "\t超過 2s沒有取到蛋糕，消費退出");
                System.out.println();
                //return的作用是不執行下面的成功語句
                return;
            }
            System.out.println(Thread.currentThread().getName() + "\t消費佇列" + result + "成功");
        }
    }

    //停止生產者消費者模型
    public void stop() throws Exception {
        flag = false;
    }

}

public class BlockingProCons {
    public static void main(String[] args) {
        //具體的實現類
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(5);
        //共享資源
        ShareData shareData = new ShareData(blockingQueue);

        //生產執行緒
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t 生產執行緒啟動");
            try {
                shareData.myIncrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"Productor").start();

        //消費執行緒
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t 消費執行緒啟動");
            try {
                shareData.myDecrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"Consumer").start();

        try {
            //主執行緒
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println();
        System.out.println();
        //主執行緒停止生產者消費者模型
        System.out.println("5s後main叫停，執行緒結束");
        try {
            shareData.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

結果：

//輸出具體的實現類
java.util.concurrent.ArrayBlockingQueue
//生產者消費者模式
Productor	 生產執行緒啟動
Consumer	 消費執行緒啟動
Productor	插入0阻塞佇列成功
Consumer	消費佇列0成功
Productor	插入1阻塞佇列成功
Consumer	消費佇列1成功
Productor	插入2阻塞佇列成功
Consumer	消費佇列2成功
Productor	插入3阻塞佇列成功
Consumer	消費佇列3成功
Productor	插入4阻塞佇列成功
Consumer	消費佇列4成功

//停止操作
5s後main叫停，執行緒結束
Productor	老闆叫停了， flag=false，生產結束
Consumer	超過 2s沒有取到蛋糕，消費退出

可以看到上述並沒有用到Lock以及synchronized，而僅僅用到了阻塞佇列以及原子整型類，就可以實現生產者消費者模型，也就是不用程式設計師關心具體的加鎖解鎖過程，而是關心具體的業務邏輯

6. synchronized和lock有什麼區別?用新的lock有什麼好處?請舉例

區別：

原始構成
- synchronized是關鍵字屬於jvm
  
  其中jvm會將其位元組碼執行為monitorenter以及monitorexit
  
  monitorenter，底層是通過monitor物件來完成，其實wait/notify等方法也依賴於monitor物件只有在同步或方法中才能掉wait/notify等方法
  
  monitorexit
- Lock是具體類，是api層面的鎖(java.util.concurrent.locks.Lock)
使用方法
- sychronized不需要使用者取手動釋放鎖，當synchronized程式碼執行完後系統會自動讓執行緒釋放對鎖的佔用
- ReentrantLock則需要使用者去手動釋放鎖若沒有主動釋放鎖，就有可能導致出現死鎖現象，需要lock()和 unlock()方法配合try/finally語句塊來完成
等待是否可中斷
- synchronized不可中斷，除非丟擲異常或者正常執行完成
- ReentrantLock可中斷，設定超時方法tryLock(long timeout, TimeUnit unit)，或者lockInterruptibly()放程式碼塊中，呼叫interrupt()方法可中斷
加鎖是否公平
- synchronized是非公平鎖
- ReentrantLock兩者都可以，預設公平鎖，構造方法可以傳入boolean值，true為公平鎖，false為非公平鎖

鎖繫結多個條件Condition

synchronized沒有
ReentrantLock用來實現分組喚醒需要要喚醒的執行緒們，可以精確喚醒，而不是像synchronized要麼隨機喚醒一個執行緒要麼喚醒全部執行緒

程式碼：

package com.yuxue.juc.queue;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * synchronized和lock區別
 * ===lock可繫結多個條件===
 * 對執行緒之間按順序呼叫，實現A>B>C三個執行緒啟動，要求如下: * AA列印5次，BB列印10次，CC列印15次
 * 緊接著
 * AA列印5次，BB列印10次，CC列印15次
 * 。。。。
 * 來十輪
 */

class DataShare {

    private volatile int num = 0;

    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print5() {
        lock.lock();
        try {
            while (num != 0) {
                c1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            num = 1;
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10() {
        lock.lock();
        try {
            while (num != 1) {
                c2.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            num = 2;
            c3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15() {
        lock.lock();
        try {
            while (num != 2) {
                c3.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            num = 0;
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class SyncAndReentrantLockDemo {
    public static void main(String[] args) {
        DataShare dataShare = new DataShare();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                dataShare.print5();
            }, "AA").start();

            new Thread(() -> {
                dataShare.print10();
            }, "BB").start();

            new Thread(() -> {
                dataShare.print15();
            }, "CC").start();
        }
    }
}

我們可以清楚地看到Lock可以建立多個Condition，同時對不同的Condition呼叫await以及signal方法，可以對不同的執行緒進行操作，這就是Lock比synchronized更方便的原因，synchronized只能對所有執行緒進行notifyall()方法，隨機喚醒執行緒

注意：notifyall()方法是Object類當中的方法！

什麼是阻塞佇列？如何使用阻塞佇列來實現生產者-消費者模型?
2018-03-14
佇列模型
阻塞佇列和生產者-消費者模式
2018-09-03
佇列模式
使用Disruptor實現生產者和消費者模型
2018-05-07
模型
記錄一次日常開發中基於阻塞佇列的生產者和消費者模型
2019-03-05
佇列模型
[Java併發程式設計實戰] 阻塞佇列 BlockingQueue(含程式碼，生產者-消費者模型)
2018-06-02
Java程式設計佇列BloC模型
使用Python佇列和多執行緒實現生產者消費者
2018-03-30
Python佇列執行緒
Java實現生產者和消費者
2021-08-19
Java
使用slice和條件變數實現一個簡單的多生產者多消費者佇列
2018-06-15
變數佇列
生產者消費者模型
2023-02-23
模型
用Go語言實現一個簡單生產者消費者模型，如何做？
2022-01-24
Go模型
實戰Spring4+ActiveMQ整合實現訊息佇列(生產者+消費者)
2019-07-15
SpringMQ佇列
PHP操作Beanstalkd佇列（2）生產者與消費者
2018-05-19
PHPBean佇列
2.Python程式間的通訊之佇列（Queue）和生產者消費者模型
2021-04-23
Python佇列模型
rabbitMQ實戰生產者-交換機-佇列-消費者細談
2024-06-21
MQ佇列
使用BlockQueue實現生產者和消費者模式
2018-05-07
BloC模式
C++ condition_variable 實現生產者消費者模型
2020-11-12
C++模型
「Kafka應用」PHP實現生產者與消費者
2021-01-20
KafkaPHP
鎖，threading local，以及生產者和消費者模型
2018-09-11
thread模型
Python並行程式設計(六)：多執行緒同步之queue(佇列)實現生產者-消費者模型
2019-04-13
Python並行行程程式設計執行緒佇列模型
python 多執行緒實現生產者與消費者模型
2018-04-14
Python執行緒模型
java實現生產者消費者問題
2021-09-09
Java
新手練習-消費者生產者模型
2018-12-29
模型
分享一個生產者-消費者的真實場景
2023-04-11
【MQ】java 從零開始實現訊息佇列 mq-02-如何實現生產者呼叫消費者？
2022-04-29
MQJava佇列
ActiveMQ 生產者和消費者demo
2021-12-07
MQ
生產者消費者
2020-11-16
從零開始實現lmax-Disruptor佇列（一）RingBuffer與單生產者、單消費者工作原理解析
2022-06-02
佇列
python多執行緒+生產者和消費者模型+queue使用
2020-06-23
Python執行緒模型
Qt基於QSemaphore的生產者消費者模型
2018-11-09
QT模型
生產者消費者模式
2020-03-03
模式
訊號量實現生產者消費者（程式碼邏輯有問題，不適合多個消費者，不常用）
2020-11-26
十五、.net core（.NET 6）搭建RabbitMQ訊息佇列生產者和消費者的簡單方法
2021-06-12
MQ佇列
使用wait（）與notifyAll（）實現生產者與消費者模式
2020-10-16
AI模式
生產者消費者問題-C++程式碼實現
2024-08-19
C++
python 生產者消費者模式
2021-09-06
Python模式
Lock 和 synchronized的區別
2018-04-11
synchronized
生產消費者模式
2021-06-10
模式
使用ZIO-Streams的Redis Stream消費者和生產者實現原始碼
2021-03-23
Redis原始碼