2. 程式人生 > >java 多執行緒併發系列之 生產者消費者模式的兩種實現

java 多執行緒併發系列之 生產者消費者模式的兩種實現

阿新 • • 發佈：2019-02-12
生產者消費者模式是併發、多執行緒程式設計中經典的設計模式，生產者和消費者通過分離的執行工作解耦，簡化了開發模式，生產者和消費者可以以不同的速度生產和消費資料。

真實世界中的生產者消費者模式

生產者和消費者模式在生活當中隨處可見，它描述的是協調與協作的關係。比如一個人正在準備食物（生產者），而另一個人正在吃（消費者），他們使用一個共用的桌子用於放置盤子和取走盤子，生產者準備食物，如果桌子上已經滿了就等待，消費者（那個吃的）等待如果桌子空了的話。這裡桌子就是一個共享的物件。

我們看這樣一個例子：生產者：  往一個公共的盒子裡面放蘋果 消費者：從公共的盒子裡面取蘋果盒子：盒子的容量不能超過5下面我們用兩者方法分別實現這樣一個場景。
方法一：   wait()  和   notify()   通訊方法實現看盒子程式碼 publicclass PublicBox { privateint apple = 0; publicsynchronized void increace() { while (apple ==5) { try {                        wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    } 
               }  apple++;  System. out .println("生成蘋果成功！" );               notify();            } publicsynchronized void decreace() { while (apple ==0) { try {                        wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    } 
               } apple--; System. out.println( "消費蘋果成功！" );               notify();            } publicstatic void main(String []args)              {                     PublicBox box= new PublicBox();                     Consumer con= new Consumer(box);                     Producer pro= new Producer(box);                     Thread t1= new Thread(con);                     Thread t2= new Thread(pro);                     t1.start();                     t2.start();              }       }生產者程式碼（定義十次）：publicclass Producer implements Runnable { private PublicBox box; public Producer(PublicBox box) { this .box = box;     } @Overridepublicvoid run() {  for( int i=0;i<10;i++)         { try {                     System. out .println("pro  i:" +i);                           Thread. sleep(30);                     } catch (InterruptedException e) { // TODO: handle exception                           e.printStackTrace();                     }box.increace();        }    } }消費者程式碼（同樣十次）：publicclass Consumer implements Runnable { private PublicBox box; public Consumer(PublicBox box) { this .box = box;     } @Overridepublicvoid run() {  for( int i=0;i<10;i++)       { try {                     System. out .println("Con: i " +i);                           Thread. sleep(3000);                // 這裡設定跟上面30不同是為了 盒子中的蘋果能夠增加，不會生產一個馬上被消費                       } catch (InterruptedException e) { // TODO: handle exception                           e.printStackTrace();                     }box.decreace();         }  } }輸出如下：pro  i:0Con: i 0生成蘋果成功！pro  i:1生成蘋果成功！pro  i:2生成蘋果成功！pro  i:3生成蘋果成功！pro  i:4生成蘋果成功！pro  i:5消費蘋果成功！Con: i 1生成蘋果成功！pro  i:6消費蘋果成功！Con: i 2生成蘋果成功！pro  i:7消費蘋果成功！生成蘋果成功！pro  i:8Con: i 3消費蘋果成功！生成蘋果成功！pro  i:9Con: i 4消費蘋果成功！生成蘋果成功！Con: i 5消費蘋果成功！Con: i 6消費蘋果成功！Con: i 7消費蘋果成功！Con: i 8消費蘋果成功！Con: i 9消費蘋果成功！方法二：採用阻塞佇列實現生產者消費者模式阻塞佇列實現生產者消費者模式超級簡單，它提供開箱即用支援阻塞的方法put()和take()，開發者不需要寫困惑的wait-nofity程式碼去實現通訊。BlockingQueue 一個介面，Java5提供了不同的現實，如ArrayBlockingQueue和LinkedBlockingQueue，兩者都是先進先出（FIFO）順序。而ArrayLinkedQueue是自然有界的，LinkedBlockingQueue可選的邊界。下面這是一個完整的生產者消費者程式碼例子，對比傳統的wait、nofity程式碼，它更易於理解。盒子程式碼：import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;publicclass PublicBoxQueue { publicstatic void main(String []args)       { BlockingQueue publicBoxQueue= newLinkedBlockingQueue(5);   //定義了一個大小為5的盒子              Thread pro= new Thread(new ProducerQueue(publicBoxQueue));              Thread con= new Thread(new ConsumerQueue(publicBoxQueue));              pro.start();              con.start();       }}生產者：package dsd;import java.util.concurrent.BlockingQueue;publicclass ProducerQueue implements Runnable { privatefinal BlockingQueueproQueue; public ProducerQueue(BlockingQueue proQueue)       { this .proQueue =proQueue;       } @Override publicvoid run() { // TODO Auto-generated method stub for (int i=0;i<10;i++)              { try {                           System. out .println("生產者生產的蘋果編號為 : " +i);  //放入十個蘋果編號 為1到10 proQueue .put(i); /*Thread.sleep(3000);*/                     } catch (InterruptedException  e) { // TODO: handle exception                           e.printStackTrace();                     }              }       }}消費者：package dsd;import java.util.concurrent.BlockingQueue;publicclass ConsumerQueue implements Runnable { privatefinal BlockingQueueconQueue; public ConsumerQueue(BlockingQueue conQueue)       { this .conQueue =conQueue;       } @Override publicvoid run() { // TODO Auto-generated method stub for (int i=0;i<10;i++)              { try {                           System. out .println("消費者消費的蘋果編號為 ：" +conQueue .take());                           Thread. sleep(3000);  //在這裡sleep是為了看的更加清楚些                     } catch (InterruptedException e) { // TODO: handle exception                           e.printStackTrace();                     }              }       }}結果如下：生產者生產的蘋果編號為 : 0生產者生產的蘋果編號為 : 1消費者消費的蘋果編號為 ：0生產者生產的蘋果編號為 : 2生產者生產的蘋果編號為 : 3生產者生產的蘋果編號為 : 4生產者生產的蘋果編號為 : 5生產者生產的蘋果編號為 : 6生產者生產的蘋果編號為 : 7消費者消費的蘋果編號為 ：1消費者消費的蘋果編號為 ：2生產者生產的蘋果編號為 : 8消費者消費的蘋果編號為 ：3生產者生產的蘋果編號為 : 9消費者消費的蘋果編號為 ：4消費者消費的蘋果編號為 ：5消費者消費的蘋果編號為 ：6消費者消費的蘋果編號為 ：7消費者消費的蘋果編號為 ：8消費者消費的蘋果編號為 ：9

生產者消費者模式的好處

它的確是一種實用的設計模式，常用於編寫多執行緒或併發程式碼。下面是它的一些優點：

  1.  它簡化的開發，你可以獨立地或併發的編寫消費者和生產者，它僅僅只需知道共享物件是誰
  2. 生產者不需要知道誰是消費者或者有多少消費者，對消費者來說也是一樣
  3.  生產者和消費者可以以不同的速度執行
  4.  分離的消費者和生產者在功能上能寫出更簡潔、可讀、易維護的程式碼

轉載自:http://blog.csdn.net/yujin753/article/details/45723175

相關推薦

java 多執行緒併發系列之 生產者消費者模式的兩種實現

生產者消費者模式是併發、多執行緒程式設計中經典的設計模式，生產者和消費者通過分離的執行工作解耦，簡化了開發模式，生產者和消費者可以以不同的速度生產和消費資料。真實世界中的生產者消費者模式生產者和消費者模式在生活當中隨處可見，它描述的是協調與協作的關係。比如一個人正在準備食物（

入坑JAVA多執行緒併發(五）生產者消費者模式

生產者消費者模式對於理解多執行緒是一個很經典，也很好的例子 資源類： class Resource{ //資源初始化個數 private int init; //資源最大個數 private int Max; p

java多執行緒併發系列之閉鎖(Latch)和柵欄（CyclicBarrier）

-閉鎖（Latch） 閉鎖（Latch）：一種同步方法，可以延遲執行緒的進度直到執行緒到達某個終點狀態。通俗的講就是，一個閉鎖相當於一扇大門，在大門開啟之前所有執行緒都被阻斷，一旦大門開啟所有執行緒都將通過，但是一旦大門開啟，所有執行緒都通過了，那麼這個閉鎖的狀態就失效了，門

Java多執行緒學習筆記(九) 生產者/消費者模式實現

1. 一個生產者和一個消費者：操作值 1.1 公共值 public class ValueObject { public static String value = ""; } 1.2 生產者 public class Producer {

一、Java多執行緒併發同步之Semaphore

概念 Semaphore是一種在多執行緒環境下使用的設施，該設施負責協調各個執行緒，用來管理資源，以保證它們能夠正確、合理的使用公共資源的設施，也是作業系統中用於控制程序同步互斥的量。用我們常見的說法就是用來控制併發數。 訊號量是一個非負整數 。 業務場景 以售

二、Java多執行緒併發同步之CyclicBarrier

概述 CyclicBarrier：可迴圈屏障，允許一組執行緒全部等待的同步輔助工具。一組執行緒互相等待，直到所有執行緒都到達某個公共屏障點(也可以叫同步點) 。它可以在等待執行緒之後重新使用。這個屏障之所以用迴圈修飾，是因為在所有的執行緒釋放彼此之後，這個屏障是

java多執行緒併發處理之阻塞佇列LinkedBlockingQueue用法

<pre name="code" class="java">public class ThreadRelatedService2 { // key point: records list must be ordered public void

Java多執行緒-併發之執行緒池

執行緒池有了解嗎？ 答： java.util.concurrent.ThreadPoolExecutor 類就是一個執行緒池。客戶端呼叫ThreadPoolExecutor.submit(Runnable task) 提交任務，執行緒池內部維護的工作者執行緒的數量就是該執行緒池的執行

Java多執行緒-併發之synchronized 關鍵字

synchronized 關鍵字 答： 底層實現： 進入時，執行 monitorenter，將計數器 +1，釋放鎖 monitorexit 時，計數器 -1 當一個執行緒判斷到計數器為 0 時，則當前鎖空閒，可以佔用；反之，當前執行緒進入等待狀態 含義

Java多執行緒-併發之sleep() 和 wait(n) 、 wait() 的區別

sleep() 和 wait(n) 、 wait() 的區別 答： sleep 方法：是 Thread 類的靜態方法，當前執行緒將睡眠 n 毫秒，執行緒進入阻塞狀態。當睡眠時間到了，會接觸阻塞，進入可執行狀態，等待 CPU 的到來。睡眠不釋放鎖（如果有的話） wai

Java多執行緒-併發之多執行緒產生死鎖的4個必要條件？如何避免死鎖？

多執行緒產生死鎖的4個必要條件？ 答： 互斥條件：一個資源每次只能被一個執行緒使用 請求與保持條件：一個執行緒因請求資源而阻塞時，對已獲得的資源保持不放 不剝奪條件：程序已經獲得的資源，在未使用完之前，不能強行剝奪 迴圈等待條件：若干執行緒之間形成一種頭

Java多執行緒-併發之執行緒和程序的區別

執行緒和程序的區別 答： 程序是一個“執行中的程式”，是系統進行資源分配和排程的一個獨立單位 執行緒是程序的一個實體，一個程序中擁有多個執行緒，執行緒之間共享地址空間和其他資源（所以通訊和同步等操作執行緒比程序更加容易） 執行緒上下文的切換比程序上下文切換要快

Java多執行緒-併發之如何制定多個執行緒的執行順序？

文章目錄 如何讓10個執行緒按照順序列印0123456789？ 程式碼如下： 1.建立一個鎖物件類 2.建立一個執行緒類 3.測試類 如何讓10個執行緒按照順序列印012

Java多執行緒--併發中集合的使用之ConcurrentSkipListMap

概述       基於跳錶實現的ConcurrentNavigableMap。 1）containsKey、get、put、remove等操作的平均時間複雜度為log(n)；size非固定時間操作，因非同步特性，需要遍歷所有節點才能確定size，且可能不是

java多執行緒併發庫高階應用 之 執行緒範圍內共享資料

轉自:http://blog.csdn.net/xushuaic/article/category/1335611 筆記摘要：  所謂執行緒範圍內共享資料，即對於相同的程式程式碼，多個模組在同一個執行緒中執行時要共享一份資料，而在另外執行緒中執行時又共

【Java多執行緒併發總結】Thread類的常用方法(join、yield等)---執行緒的基礎操作篇

 啟動(start)   最基本的操作，呼叫Runnable中的run方法，無返回值。 new Thread(new Test()).start(); 休眠(sleep)  使當前執行緒休眠一段時間，預設為毫秒級，最高可以精確到納秒，呼叫的方法為slee

java多執行緒案例1之簡單銀行取款問題及其優化

      之前學java的時候，學校老師由於課時問題，沒有教我們多執行緒，最近學校外聘的企業教師給我們做實訓要用到多執行緒，因此才初步瞭解多執行緒，以下這個案例只是介紹java程式碼優化，程式碼中有涉及多執行緒，但今天不對其講解，只簡單講解程式碼優化的問題,希望對初學者有幫

java 多執行緒併發實質

首先我們都知道多執行緒在獲取共享資源時，往往會出現意想不到的結果，這是為什麼呢？執行緒獲取共享資源的過程如下圖： 首先我們需要了解jvm記憶體結構，在這裡不過多說明，由上圖我們可以知道，在jvm記憶體中分為獨立記憶體和共享記憶體，獨立記憶體是我們每個執行緒獨有的資訊，而

Java多執行緒乾貨系列—（一）Java多執行緒基礎

多執行緒併發程式設計是Java程式設計中重要的一塊內容，也是面試重點覆蓋區域，所以學好多執行緒併發程式設計對我們來說極其重要，下面跟我一起開啟本次的學習之旅吧。 正文 執行緒與程序 1 執行緒：程序中負責程式執行的執行單元 執行緒本身依靠程式進行執行 執行緒是程式中的順序控制流，只能使用分配給程式的資源和環

JAVA多執行緒併發Demo

一個最簡單的多執行緒併發demo： 主函式： public class multithreadReq { private static final int THREADNUM = 5;/