2. 程式人生 > >JAVA執行緒（生產者與消費者）

JAVA執行緒（生產者與消費者）

阿新 • • 發佈：2019-02-06
業務需求： 
    生產20個饅頭，籃子裡只能放6個饅頭。 
    消費者發現籃子裡有饅頭可以食用時即可把饅頭取出開始使用，直到籃子裡饅頭為空。 
    生產者發現籃子裡的饅頭不滿足6個時，生產者開始生產饅頭並放入籃子中。 

具體實現： 

第一步：建立盛放饅頭的籃子類 

 Java程式碼  收藏程式碼
  1. publicclass SyncBasket {  
  2.     public Bread[] breads = new Bread[6];  
  3.     privateint index = 0;  
  4.     publicsynchronizedvoid push(Bread bread ) {  
  5.         while(index==this.breads.length){  
  6.             try{  
  7.                 this.wait();  
  8.             }catch(InterruptedException e){  
  9.                 e.printStackTrace();  
  10.             }     
  11.         }  
  12.         this.notifyAll();  
  13.         breads[index]=bread;  
  14.         index++;  
  15.     }  
  16.     public
    synchronized Bread pop() {  
  17.         while(index==0){  
  18.             try{  
  19.                 this.wait();  
  20.             }catch(InterruptedException e){  
  21.                 e.printStackTrace();  
  22.             }  
  23.         }  
  24.         this.notifyAll();  
  25.         index--;  
  26.         return breads[index];  
  27.     }  
  28. }  


第二步：建立生產者類 
Java程式碼  收藏程式碼
  1. publicclass Producer implements Runnable {  
  2.     private SyncBasket basket;  
  3.     public Producer(SyncBasket basket) {  
  4.         this.basket = basket;  
  5.     }  
  6.     publicvoid run() {  
  7.         for(int i=1;i<21;i++){  
  8.             Bread bread = new Bread(i);  
  9.             basket.push(bread);  
  10.             System.out.println("producer produce: " + bread);  
  11.             try {  
  12.                 Thread.sleep((int) (Math.random() * 1000));  
  13.             } catch (InterruptedException e) {  
  14.                 e.printStackTrace();  
  15.             }  
  16.         }  
  17.     }  
  18. }  


第三步：建立消費者類 
Java程式碼  收藏程式碼
  1. publicclass Consumer implements Runnable {  
  2.     private SyncBasket basket;  
  3.     public Consumer(SyncBasket basket) {  
  4.         this.basket = basket;  
  5.     }  
  6.     publicvoid run() {  
  7.         for(int i=0; i<20; i++) {  
  8.             Bread bread = basket.pop();  
  9.             System.out.println("Consumer eat: "+bread);  
  10.             try {  
  11.                 Thread.sleep((int) (Math.random() * 1000));  
  12.             } catch (InterruptedException e) {  
  13.                 e.printStackTrace();  
  14.             }  
  15.         }  
  16.     }  
  17. }  


第四步：建立饅頭物件類 
Java程式碼  收藏程式碼
  1. publicclass Bread {  
  2.     privateint id;  
  3.     public Bread(int id){  
  4.         this.id=id;  
  5.     }  
  6.     @Override
  7.     public String toString() {  
  8.         return String.valueOf(id);  
  9.     }         
  10. }  


第五步：建立測試類 
Java程式碼  收藏程式碼
  1. publicclass TestProConsumer {  
  2.     publicstaticvoid main(String[] args) {  
  3.         SyncBasket basket=new SyncBasket();  
  4.         Producer producer=new Producer(basket);  
  5.         Consumer consumer=new Consumer(basket);  
  6.         new Thread(producer).start();  
  7.         new Thread(consumer).start();  
  8.     }  
  9. }  


到此生產者消費者的小例子結束，希望能起到拋磚引玉的作用。

相關推薦

JAVA執行緒（生產者與消費者）

業務需求：      生產20個饅頭，籃子裡只能放6個饅頭。      消費者發現籃子裡有饅頭可以食用時即可把饅頭取出開始使用，直到籃子裡饅頭為空。      生產者發現籃子裡的饅頭不滿足6個時，生產者開始生產饅頭並放入籃子中。  具體實現：  第一步：建立盛放饅頭的籃子類

JAVA 多執行緒（生產者和消費者模式）

在生產-消費模式中：通常由兩類執行緒，即若干個生產者的執行緒和若干個消費者的執行緒。生產者執行緒負責提交使用者請求，消費者執行緒則負責具體處理生產者提交的任務，在生產者和消費者之間通過共享記憶體快取區進行通訊。 主要構成： provider:生產者執行緒負責生產資料 consume

執行緒協作:生產者與消費者

pv （page view）: 每個頁面的訪問量（併發） uv (unique view）: 每個使用者的訪問量 / 唯一的訪問量 vv （visit view）: 訪問量 (早上訪問一次，下午訪問一次，算訪問2次) 分析：這時一個執行緒同步問題，生產者和消費者 共

Java執行緒之生產者和消費者

Java執行緒的作用是可以使一個程式中的執行緒可以並行執行，這樣可以大大縮短程式執行所需要的時間。但是當這些執行緒都對同一個變數或者記憶體進行操作的時候如果不加以控制就會出現許多不可預見的錯誤，而且在不同時間執行也會產生不同的錯誤，並且很難排查。 對於生產者和消

Java執行緒協作--生產者和消費者模式

    生產者消費者模式是執行緒協作的經典應用，主要由具體產品類，容器類，生產者執行緒，消費者執行緒組成。具體表現形式為生產者執行緒生產產品往容器裡放置，當容器滿的時候，生產執行緒呼叫wait方法，使當前執行緒阻塞，而此時消費者執行緒在不斷的消費容器裡的產品，同時呼叫noti

多執行緒實現生產者與消費者模式

生產者-消費者模式的簡介： 在實際的軟體開發過程中，我們將產生資料的模組稱為生產者，處理資料的模組成為消費者。但僅有這兩者還不夠成為一個生產者-消費者模式，還需要有一個緩衝區（一段記憶體區域）作為中介，生產者產生的資料放入緩衝區，消費者從緩衝區讀取資料並處理。

《Java多執行緒程式設計實戰》——第七章Producer-Consumer（生產者／消費者）模式

Producer-Consumer模式的核心是通過通道對資料（或任務）的生產者和消費者進行解耦，從而使二者的處理速率相對來說互不影響。 類圖 BlockingQueueChannel: 當佇列滿時，將當前執行緒掛起直到佇列非滿 當佇列為空時，將當前執行緒掛起直到佇列

生產者與消費者模式（執行緒的同步與互斥）

條件變數 條件變數的提出首先要涉及一個概念，就是生產者消費者模型： 生產者消費者，是在多執行緒同步的一個問題，兩個固定大小緩衝區的執行緒，在實際執行是會發生問題，生產者是生成資料放入緩衝區，重複過程，消費者在緩衝區取走資料。 生產者消費者的模型提出了三種關係，兩種角色，

Java 執行緒（Thread）技術與深入理解

Thread基礎部分 在各種程式語言中都有thread（執行緒）技術，執行緒保證在一個main中（主執行緒）可以同時進行兩個或多個不同的事件，通俗點說就是你在上廁所的同時還可以玩手機，是吧！美滋滋。而Thread就相當於提供了同時做兩件事的條件和環境。接下來在深入一點理解計算機中的Threa

QTcreator 多執行緒（生產者消費者）

qt應用的多執行緒例項簡單實現，語法超級簡單，用兩種方法實現同步和互斥。一種是Semaphore訊號量，另一種是mutex鎖和condition條件變數。下面開始。第一種，QSemaphore訊號量方式：通過Qt Creator建立一個控制檯專案，專案建立完以後只有一個mai

Ｃ語言執行緒例項（生產者和消費者）

附上程式碼，作為以後的參考。 /***********main.c************/ #include "customer.h" #include "producer.h" #include "data.h" #include <pthread.h>

Java-執行緒（十個執行緒實現1~100求和）

這道題我大概搞了兩個小時左右吧。 可是我發現總是不對，最後發現我做不出來了，因為我並未真正搞清整個程式的執行，以及對那些關鍵詞（我指的是synchronized、wait()、notify()等這些玩意兒）的理解和使用都不清楚，更別說寫出來整個程式了。 public class Fort

多執行緒（模擬買票）-----java基礎知識總結

這次的的問題引入的比較深入，如果看了這篇部落格，不看下一篇，你會很懵逼。 程式碼： 1 package com.day13.math; 2 /** 3 * 類說明 :模擬三個視窗同時售票 4 * @author 作者 : chenyanlong 5 * @versi

java 執行緒 （二） 執行緒池

  package cn.sasa.demo2; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public stat

java 執行緒 （三）執行緒併發的安全性 同步程式碼塊

  package cn.sasa.demo1; import java.util.concurrent.ExecutionException; public class ThreadDemo { public static void main(String[] args) th

程序與執行緒（沒整理好）

基礎知識 併發（一人一段時間做多事）（充分利用資源，提高CPU的利用率） 在作業系統中，併發是指一個時間段中有幾個程式都處於已啟動執行到執行完畢之間，且這幾個程式都是在同一個處理機上執行，但任一個時刻點上只有一個程式在處理機上執行。 並行（多

java執行緒（上）——執行緒狀態及屬性詳解

在作業系統中，我們通過分時的方法在CPU上不斷地切換處理多個程序任務，給人並行處理的感覺，這種方法在作業系統中叫做多工。多工在較低層次上擴展出多執行緒的概念，也就是指一個程式同時執行多個執行緒。這種可以同時執行一個以上的執行緒的程式，我們叫做多執行緒程式。

JAVA——多執行緒（碰撞的球）

多執行緒（碰撞的球） 1.要求 本例項運用多執行緒控制球的運動，通過視窗中的滑條，對球的大小和顏色進行選擇後，隨機從視窗左右兩方擇一進入，小球在遇到障礙或邊界後會折回。 2.原理 多執行緒是為了使得多個執行緒並行地工作以完成多項任務，以提高系統的效率。執行緒

Linux下的多執行緒程式設計二（執行緒的同步與互斥）

一、什麼叫做執行緒的同步與互斥？為什麼需要同步與互斥？ 1、同步與互斥 互斥：是指某一資源同時只允許一個訪問者對其進行訪問，具有唯一性和排它性。但互斥無法限制訪問者對資源的訪問順序，即訪問是無序的。 同步：是指在互斥的基礎上（大多數情況），通過其它機制

JAVA執行緒（補充）

執行緒優先順序 package com.thread.priority; /** * 執行緒優先順序：每個執行緒都有一個優先順序，高優先順序的執行緒執行優先於低優先順序執行緒 * 預設優先順序：5 * 範圍：1-10 * 這個只有在次數特別多的情況下，效果才可能比較明顯 *