Java精講：生產者-消費者

VPointer 發布于2019-08-16 15:06 / 1141人閱讀

摘要：創建一個阻塞隊列生產者生產，目前總共有消費者消費，目前總共有原文鏈接更多教程

原文鏈接 更多教程 本文概要

生產者和消費者問題是線程模型中老生常談的問題，也是面試中經常遇到的問題。光在Java中的實現方式多達數十種，更不用說加上其他語言的實現方式了。那么我們該如何學習呢？

本文會通過精講wait()和notify()方法實現生產者-消費者模型，來學習生產者和消費者問題的原理。

目的是當你理解了最簡單實現原理，再看其他的實現，無非使用了更高級的機制（例如鎖、信號量、管道等等）來照貓畫虎的實現這個原理，萬變不離其宗，它們的原理都是一樣的。

本文也會列出一部分其他的實現方式代碼。千萬不要嘗試去背誦所有實現代碼，只有掌握了實現原理才能遇到問題的時候游刃有余。

精講wait()和notify()方法實現生產者-消費者模型

啥是生產者-消費者模型：

生產者和消費者在同一時間段內共用同一個存儲空間，生產者往存儲空間中添加產品，消費者從存儲空間中取走產品，當存儲空間為空時，消費者阻塞，當存儲空間滿時，生產者阻塞。

現實生活中的例子：12306搶購火車票、淘寶購買商品、倉庫管理等。

分步的實現我們的模型

public class Test1 {
    private static Integer count = 0;  //代表生產的商品數量
    private static final Integer FULL = 10;  //代表商品最多多少個（也就是緩沖區大小）
    private static final Object LOCK = new Object(); //鎖對象  ----分析1

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {   //創造一堆生產者和消費者模擬真實環境
            new Thread(new Producer()).start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(new Consumer()).start();
        }
    }

    static class Producer implements Runnable { //代表生產者
        @Override
        public void run() {
           
        }
    }

    static class Consumer implements Runnable {  //代表消費者
        @Override
        public void run() {
          
        }
    }
}

分析1.在main函數中創建了5個消費者線程任務和5個生產者線程任務，當這10個線程同時運行時，需要保證生產者和消費者所公用的緩沖區是同步被改變的，就是說不同線程訪問緩沖區的數據不能發生錯亂。這里就是用一個鎖來保證緩沖區每次只有一個線程訪問

接下來看下生產者和消費者的實現：

static class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {  //一次多生產幾個商品
                try {
                    Thread.sleep(3000);  //模擬真實環境，讓生產的慢一點，間隔3秒
                } catch (Exception e) {
                    e.printStackTrace();
                }

                synchronized (LOCK) {  //線程同步  
                    while (count.equals(FULL)) {  //當緩沖區滿了  
                        try {
                            LOCK.wait();   //讓線程等待  ----分析1
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count++;  //緩沖區不滿時繼續生產商品，商品加一
                    System.out.println(Thread.currentThread().getName() + "生產者生產，目前總共有" + count);
                    LOCK.notifyAll(); //喚醒等待的消費者
                }
            }
        }
    }

    static class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {  
                    while (count == 0) {  //當沒有商品時，需要等待生產者生產商品
                        try {
                            LOCK.wait();   //----分析 2
                        } catch (Exception e) {
                        }
                    }
                    count--; //商品被消耗，商品減一
                    System.out.println(Thread.currentThread().getName() + "消費者消費，目前總共有" + count);
                    LOCK.notifyAll();  //商品被消耗后，通知等待的生產者
                }
            }
        }
    }

分析：
1.當緩沖區滿了的時候，需要阻止生產者繼續生產商品
2.當緩沖區為空，沒有商品時，需要阻止消費者繼續消費商品

相信代碼分析和詳細的注釋，你已經能很好的理解這個生產者-消費者模型的原理了。接下來貼出其他的幾種實現代碼。

原文鏈接 更多教程 其他的實現方法代碼

使用鎖實現：

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

public class Test1 {
    private static Integer count = 0;
    private static final Integer FULL = 10;
    //創建一個鎖對象
    private Lock lock = new ReentrantLock();
    //創建兩個條件變量，一個為緩沖區非滿，一個為緩沖區非空
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
    }
    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //獲取鎖
                lock.lock();
                try {
                    while (count == FULL) {
                        try {
                            notFull.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName()
                            + "生產者生產，目前總共有" + count);
                    //喚醒消費者
                    notEmpty.signal();
                } finally {
                    //釋放鎖
                    lock.unlock();
                }
            }
        }
    }
    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                lock.lock();
                try {
                    while (count == 0) {
                        try {
                            notEmpty.await();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()
                            + "消費者消費，目前總共有" + count);
                    notFull.signal();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}

使用阻塞隊列：
當隊列滿了或空了的時候進行入隊列操作都會被阻塞。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Test1 {
    private static Integer count = 0;
    //創建一個阻塞隊列
    final BlockingQueue blockingQueue = new ArrayBlockingQueue<>(10);
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
        new Thread(test1.new Producer()).start();
        new Thread(test1.new Consumer()).start();
    }
    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    blockingQueue.put(1);
                    count++;
                    System.out.println(Thread.currentThread().getName()
                            + "生產者生產，目前總共有" + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                try {
                    blockingQueue.take();
                    count--;
                    System.out.println(Thread.currentThread().getName()
                            + "消費者消費，目前總共有" + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

原文鏈接 更多教程

云服務器 GPU云服務器線程java生產者消費者 java生產者消費生產者消費者生產者消費者問題

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/73274.html

設計模式之建造者模式

摘要：建造者實現抽象類的所有未實現的方法，具體來說一般是兩項任務組建產品返回組建好的產品。 0x01.定義與類型定義：將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。用戶只需指定需要建造的類型就可以得到他們，建造過程及細節不需要知道類型：創建型實現建造模式的兩種方式 1.抽象建造者 UML： showImg(https://segmentfault.co...

banana_pi 2019-08-16 17:58 評論0 收藏0
消息中間件——RabbitMQ（三）理解RabbitMQ核心概念和AMQP協議！

摘要：后續介紹交換機，生產者直接將消息投遞到中。消息，服務器和應用程序之間傳送的數據，由和組成。也稱為消息隊列，保存消息并將它們轉發給消費者。主要是應為和有一個綁定的關系。 showImg(https://img-blog.csdnimg.cn/20190509221741422.gif); showImg(https://img-blog.csdnimg.cn/20190731191914...

sihai 2019-08-19 10:32 評論0 收藏0
大廠算法面試之leetcode精講9.位運算

摘要：空間復雜度方法是否為最大的冪的約數思路最大的的冪為，判斷是否是的約數即可。復雜度時間復雜度，一個整數統計二進制的復雜度，最壞的情況下是。大廠算法面試之leetcode精講9.位運算視頻教程（高效學習）:點擊學習目錄：1.開篇介紹2.時間空間復雜度3.動態規劃4.貪心5.二分查找6.深度優先&廣度優先7.雙指針...

番茄西紅柿 2021-11-29 10:50 評論0 收藏2637
大廠算法面試之leetcode精講7.雙指針

摘要：空間復雜度雙指針，循環數組，較小的那個先向內移動如果高的指針先移動，那肯定不如當前的面積大計算面積更新最大面積相交鏈表方法哈希表思路將鏈表存入中，第一個相同的節點就是重合的節點復雜度時間復雜度，分別是兩個鏈表的長度。大廠算法面試之leetcode精講7.雙指針視頻教程（高效學習）:點擊學習目錄：1.開篇介紹2...

不知名網友 2021-11-26 11:11 評論0 收藏0