Java多執行緒-----實現生產者消費者模式的幾種方式

阿新 • • 發佈：2018-12-22

1 生產者消費者模式概述

生產者消費者模式就是通過一個容器來解決生產者和消費者的強耦合問題。生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，所以生產者生產完資料之後不用等待消費者處理，

直接扔給阻塞佇列，消費者不找生產者要資料，而是直接從阻塞佇列裡取，阻塞佇列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。這個阻塞佇列就是用來給生產者和消費者解耦的。

線上程世界裡，生產者就是生產資料的執行緒，消費者就是消費資料的執行緒。在多執行緒開發當中，如果生產者處理速度很快，而消費者處理速度很慢，那麼生產者就必須等待消費者處理完，

才能繼續生產資料。同樣的道理，如果消費者的處理能力大於生產者，那麼消費者就必須等待生產者。為了解決這種生產消費能力不均衡的問題，所以便有了生產者和消費者模式

2 實現生產者消費者模式

產品類

package com.thread.pc.blockingqueue;

import java.util.UUID;

/**
 * 產品類
 * 
 * @author yyx 2018年12月22日
 */
public class Product {
    private UUID proCode; // 產品唯一編碼 


    public Product(UUID proCode) {
        super();
        this.proCode = proCode;
    }

    public UUID getProCode() {
        return proCode;
    }

    public void setProCode(UUID proCode) {
        this.proCode = proCode;
    }

}

生產者

package com.thread.pc.blockingqueue;

 
/**
 * 生產者
 * @author yyx 2018年12月22日
 */
public class Producer implements Runnable {
    private Warehouse warehouse;

    public Producer(Warehouse warehouse) {
        super();
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            warehouse.addProduct();
        }
    }

}

消費者

package com.thread.pc.blockingqueue;
/**
 * 消費者
 * @author yyx 2018年12月22日
 */
public class Consumer implements Runnable {
    private Warehouse warehouse;

    public Consumer(Warehouse warehouse) {
        super();
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            warehouse.removeProduct();
        }
    }
}

2.1 使用lock、condition和await、singalAll

倉庫類

package com.thread.pc.lockcondition;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 倉庫類
 * 
 * @author yyx 2018年12月22日
 */
public class Warehouse {
    private final int MAX_SIZE = 10;
    private List<Product> listProduct;
    private Lock lock;
    private Condition producerCondition;
    private Condition consumerCondition;

    public Warehouse(List<Product> listProduct, Lock lock, Condition producerCondition, Condition consumerCondition) {
        super();
        this.listProduct = listProduct;
        this.lock = lock;
        this.producerCondition = producerCondition;
        this.consumerCondition = consumerCondition;
    }

    public void addProduct() {
        lock.lock();
        try {
            String currentName = Thread.currentThread().getName();
            if (listProduct.size() >= MAX_SIZE) {
                try {
                    System.out.println("產品列表已滿，不再生產！" + currentName + "進入等待");
                    producerCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                Product product = new Product(UUID.randomUUID());
                System.out.println(currentName + "生產了一個產品，它的編號是：" + product.getProCode().toString());
                listProduct.add(product);
                consumerCondition.signalAll();
            }
        } finally {
            lock.unlock();
        }
    }

    public void removeProduct() {
        lock.lock();
        try {
            String currentName = Thread.currentThread().getName();
            if (listProduct.size() <= 0) {
                try {
                    System.out.println("產品列表不足，不再消費！" + currentName + "進入等待");
                    consumerCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                Product product = listProduct.get(0);
                System.out.println(currentName + "消費了一個產品，它的編號是：" + product.getProCode().toString());
                listProduct.remove(0);
                producerCondition.signalAll();
            }
        } finally {
            lock.unlock();
        }
    }
}

測試類

package com.thread.pc.lockcondition;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 測試類
 * @author 2018年12月22日
 */
public class TestModel {
    public static void main(String[] args) {
        List<Product> listProduct=new ArrayList<Product>();
        Lock lock = new ReentrantLock();
        Condition producerCondition = lock.newCondition();
        Condition consumerCondition = lock.newCondition();
        
        Warehouse warehouse = new Warehouse(listProduct,lock, producerCondition, consumerCondition);
        Producer producer = new Producer(warehouse);
        Consumer consumer = new Consumer(warehouse);
        
        new Thread(producer).start();
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

2.2 使用synchronized修飾方法

倉庫類

package com.thread.pc.synchronizedmethod;

import java.util.List;
import java.util.UUID;

/**
 * 倉庫類
 * 
 * @author yyx 2018年12月22日
 */
public class Warehouse {
    private final int MAX_SIZE = 10;
    private List<Product> listProduct;

    public Warehouse(List<Product> listProduct) {
        super();
        this.listProduct = listProduct;
    }

    public void addProduct() {
        synchronized (listProduct) {
            String currentName = Thread.currentThread().getName();
            if (listProduct.size() >= MAX_SIZE) {
                try {
                    System.out.println("產品列表已滿，不再生產！" + currentName + "進入等待");
                    listProduct.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                Product product = new Product(UUID.randomUUID());
                System.out.println(currentName + "生產了一個產品，它的編號是：" + product.getProCode().toString());
                listProduct.add(product);
                listProduct.notifyAll();
            }
        }
    }

    public void removeProduct() {
        synchronized (listProduct) {
            String currentName = Thread.currentThread().getName();
            if (listProduct.size() <= 0) {
                try {
                    System.out.println("產品列表不足，不再消費！" + currentName + "進入等待");
                    listProduct.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                Product product = listProduct.get(0);
                System.out.println(currentName + "消費了一個產品，它的編號是：" + product.getProCode().toString());
                listProduct.remove(0);
                listProduct.notifyAll();
            }
        }
    }
}

測試類

package com.thread.pc.synchronizedmethod;

import java.util.ArrayList;
import java.util.List;

/**
 * 測試類
 * 
 * @author yyx 2018年12月22日
 */
public class TestModel {
    public static void main(String[] args) {
        List<Product> listProduct = new ArrayList<Product>();

        Warehouse warehouse = new Warehouse(listProduct);
        Producer producer = new Producer(warehouse);
        Consumer consumer = new Consumer(warehouse);

        new Thread(producer).start();
        new Thread(producer).start();
        new Thread(consumer).start();
        new Thread(consumer).start();
    }
}

2.3 使用synchronized修飾程式碼塊

倉庫類

package com.thread.pc.synchronizedcodeblock;

import java.util.List;
import java.util.UUID;
/**
 * 倉庫類
 * @author yyx 2018年12月22日
 */
public class Warehouse {
    private final int MAX_SIZE = 10;
    private List<Product> listProduct;

    public Warehouse(List<Product> listProduct) {
        super();
        this.listProduct = listProduct;
    }

    public synchronized void addProduct() {
        String currentName = Thread.currentThread().getName();
        if (listProduct.size() >= MAX_SIZE) {
            try {
                System.out.println("產品列表已滿，不再生產！" + currentName + "進入等待");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            Product product = new Product(UUID.randomUUID());
            System.out.println(currentName + "生產了一個產品，它的編號是：" + product.getProCode().toString());
            listProduct.add(product);
            notifyAll();
        }
    }

    public synchronized void removeProduct() {
        String currentName = Thread.currentThread().getName();
        if (listProduct.size() <= 0) {
            try {
                System.out.println("產品列表不足，不再消費！" + currentName + "進入等待");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            Product product = listProduct.get(0);
            System.out.println(currentName + "消費了一個產品，它的編號是：" + product.getProCode().toString());
            listProduct.remove(0);
            notifyAll();
        }
    }
}

測試類

package com.thread.pc.synchronizedcodeblock;

import java.util.ArrayList;
import java.util.List;
/**
 * 測試類
 * @author yyx 2018年12月22日
 */
public class TestModel {
    public static void main(String[] args) {
        List<Product> listProduct=new ArrayList<Product>();
        
        Warehouse warehouse = new Warehouse(listProduct);
        Producer producer = new Producer(warehouse);
        Consumer consumer = new Consumer(warehouse);
        
        new Thread(producer).start();
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

2.4 使用BlockingQueue

倉庫類

package com.thread.pc.blockingqueue;

import java.util.UUID;
import java.util.concurrent.BlockingQueue;
/**
 * 倉庫
 * @author yyx 2018年12月22日
 */
public class Warehouse {
    private final int MAX_SIZE = 10;
    private BlockingQueue<Product> blockingQueue;

    public Warehouse(BlockingQueue<Product> blockingQueue) {
        super();
        this.blockingQueue = blockingQueue;
    }

    public void addProduct() {
        String currentName = Thread.currentThread().getName();
        if (blockingQueue.size() >= MAX_SIZE) {
            System.out.println("產品列表已滿，不再生產！" + currentName + "進入等待");
        } else {
            Product product = new Product(UUID.randomUUID());
            System.out.println(currentName + "生產了一個產品，它的編號是：" + product.getProCode().toString());
            try {
                blockingQueue.put(product);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void removeProduct() {
        String currentName = Thread.currentThread().getName();
        if (blockingQueue.size() <= 0) {
            System.out.println("產品列表不足，不再消費！" + currentName + "進入等待");
        } else {
            try {
                Product product = blockingQueue.take();
                System.out.println(currentName + "消費了一個產品，它的編號是：" + product.getProCode().toString());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

測試類

package com.thread.pc.blockingqueue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
 * 測試類
 * @author yyx 2018年12月22日
 */
public class TestModel {
    public static void main(String[] args) {
        BlockingQueue<Product> blockingQueue = new LinkedBlockingQueue<>(10);
        
        Warehouse warehouse = new Warehouse(blockingQueue);
        Producer producer = new Producer(warehouse);
        Consumer consumer = new Consumer(warehouse);
        
        new Thread(producer).start();
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

Java多執行緒-----實現生產者消費者模式的幾種方式

1 生產者消費者模式概述生產者消費者模式就是通過一個容器來解決生產者和消費者的強耦合問題。生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，所以生產者生產完資料之後不用等待消費者處理，直接扔給阻塞佇列，消費者不找生產者要資料，

JAVA多執行緒--實現生產者/消費者模型：一對一

要實現的功能：執行緒A將一個數據放入佇列，然後通知B進行處理，B處理完後再通知A放一個數據入佇列。 package javathreadlearn; import java.util.LinkedList; import java.util.List; import java.util.Map;

java多執行緒解決同步問題的幾種方式、原理和程式碼

生產者類： publicclassProducerextendsThread{// 每次生產的產品數量privateint num;// 所在放置的倉庫privateStorage storage;// 建構函式，設定倉庫publicProducer(Storage storage){this.stora

多執行緒，生產者消費者模式經典講解，簡單易懂2

本模式以一個經典練習為案例：使用2種鎖機制實現生產者和消費者模式要求練習（生產者消費者模式）：自定義同步容器，容器容量上限為10。可以在多執行緒中應用，並保證資料執行緒安全。使用synchronized同步及wait()和notifyAll() 實現生產者消費者模式邏

OS:(Linux)多執行緒實現生產者-消費者問題--pthread庫

OS實驗——多執行緒實現生產者-消費者問題時，正確輸入程式碼生成檔案pthread.c，在終端執行： gcc編譯：輸入gcc -o pthread pthread.c 無法成功編譯，錯誤提示如下： CSDN查詢解決方案後，發現pthread庫並不是Linux系統預設的庫，連結時需要使

java多執行緒 kfc 生產者消費者問題

package threadpractice.practice2; public class KFC{ volatile static int num = 0; public KFC() { } public void producer() { synchronized (this) { while

Java多執行緒之生產者消費者問題：使用synchronized 關鍵字解決生產者消費者問題

今天看了一片博文，講Java多執行緒之執行緒的協作，其中作者用程式例項說明了生產者和消費者問題，但我及其他讀者發現程式多跑幾次還是會出現死鎖，百度搜了下大都數的例子也都存在bug，經過仔細研究發現其中的問題，並解決了，感覺有意義貼出來分享下。

Java多執行緒之生產者消費者問題：使用重入鎖、條件變數優雅地解決生產者消費者問題

Java5中新增了大量執行緒同步的功能，比如顯式Lock，讀寫鎖ReadWriteLock，條件變數Condition等，雖然這些功能使用之前的synchronized同步關鍵字都可能實現，但自己使用同步關鍵字不僅管理混亂，而且容易出錯。如下是使用顯式Lo

java多執行緒之生產者消費者經典問題

看過 http://blog.csdn.net/thinkpadshi/article/details/8163751 下面的評論說: 感覺你的程式碼有問題啊，兩個run()方法裡面的列印語句的執行先後問題，假設開始在消費時index==0;這時wait()了

多執行緒之生產者/消費者模式（值操作）

1、一個生產者，一個消費者（值操作）本小節是典型的單個生產者，單個消費者，生產物件為值的Demo 如下，我們假設ValueObject .value為生產的值，當value的值為 “”（空串）時，我們認為生產出來的物件已被消費，當value的值不為空串時，

java多執行緒之生產者消費者佇列

package com.eshroe.sweetop.concurrency; import java.util.Random; import java.util.concurrent.Executor

多執行緒實現內部類的兩種方式

public static void main(String[] args) {// TODO Auto-generated method stub//第一種，繼承Thread類，來實現內部類new Thread(){@Overridepublic void run() {

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

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

Java多執行緒之——生產者、消費者簡單實現

生產者與消費者模式是本科課程《作業系統》中較為重要的內容之一。當時只是囫圇吞棗的理解個大概。其實生產者消費者問題是研究多執行緒程式時繞不開的經典問題之一，實質上，很多後臺服務程式併發控制的基本原理都可以歸納為生產者/消費者模式。 1、問題描述：生產

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

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

用Python多線程實現生產者消費者模式爬取鬥圖網的表情圖片

Python什麽是生產者消費者模式某些模塊負責生產數據，這些數據由其他模塊來負責處理（此處的模塊可能是：函數、線程、進程等）。產生數據的模塊稱為生產者，而處理數據的模塊稱為消費者。在生產者與消費者之間的緩沖區稱之為倉庫。生產者負責往倉庫運輸商品，而消費者負責從倉庫裏取出商品，這就構成了生產者消費者模式。生

Java多執行緒實現電影院售票案例

某電影院目前正在上映賀歲大片，共有100張票，而它有3個售票視窗，請設計一個程式模擬該電影院售票。定義Sell類實現Runnable介面，很好的解決了單繼承共享資源問題 public class Sell implements Runnable { // 定義100張票，三個售票

Java 多執行緒實現死鎖場景

簡述：《Java 程式設計思想》 P718 ~ P722 模擬死鎖的場景，三個人三根筷子，每個人需要拿到身邊的兩根筷子才能開始吃飯出現死鎖的場景是，三個人都拿到了右邊的筷子，但是由於筷子都被搶佔，均無法獲得左邊的筷子 Chopstick.java

java:多執行緒(實現Runnable的原理)及二種方式的區別

* 1,看Thread類的建構函式,傳遞了Runnable介面的引用 * 2,通過init()方法找到傳遞的target給成員變數的target賦值 * 3,檢視run方法,發現run方法中有判斷,如果target不為null就會呼叫Runnable介面子類物件的run方法 *

Java多執行緒實現的方式

Java多執行緒實現的方式有四種 1.繼承Thread類，重寫run方法 2.實現Runnable介面，重寫run方法，實現Runnable介面的實現類的例項物件作為Thread建構函式的target 3.通過Callable和FutureTask建立執行緒 4.通過執行緒池建立執行

Java多執行緒-----實現生產者消費者模式的幾種方式

1 生產者消費者模式概述

2 實現生產者消費者模式

2.1 使用lock、condition和await、singalAll

2.2 使用synchronized修飾方法

2.3 使用synchronized修飾程式碼塊

2.4 使用BlockingQueue

相關推薦