2. 程式人生 > >第二十二講 多執行緒——多執行緒間的通訊——多個生產者和消費者的升級解決方案

第二十二講 多執行緒——多執行緒間的通訊——多個生產者和消費者的升級解決方案

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

這裡我也是採用循序漸進的方式來講解JDK1.5版本中提供的多執行緒升級解決方案，希望能更加容易地讓大家接受。 為了解決多生產多消費的效率低下這一核心問題，在這兒我就告訴大家勢必要用到JDK1.5中java.util.concurrent.locks包中的物件，其中就有Lock介面。須知同步程式碼塊或者同步函式的鎖操作是隱式的，而JDK1.5中出現的Lock介面按照面向物件的思想，將鎖單獨封裝成了一個物件，並提供了對鎖的顯示操作，諸如以下操作：

  • lock()：獲取鎖；
  • unlock()：釋放鎖。

總而言之，Lock介面的出現比synchronized有了更多的操作，它就是同步的替代。所以我們首先將多個生產者和消費者案例中的同步更換為Lock介面的形式，程式碼如下，供大家參考。

import java.util.concurrent.locks.*;
// 描述資源
class Res
{
    private String name; // 資源名稱
    private int count = 1; // 資源編號
    // 建立新Lock
    private Lock lock = new ReentrantLock();
    // 定義標記。
    private boolean flag;
    // 提供了給商品賦值的方法
    public void set(String name) //
    {
        // 獲取鎖。
        lock.lock
 
();

        try
        {
            while (flag) // 判斷標記為true，就執行wait()等待。為false，就生產。
                try{this.wait();}catch(InterruptedException e){ } // t0(等待)、t1(等待)
            this.name = name + "--" + count; // 麵包1、麵包2、麵包3

            count++; // 4
            System.out.println(Thread.currentThread
 
().getName() + "...生產者..." + this.name); // t0、麵包1  t0、麵包2、t1、麵包3
            // 生產完畢，將標記改為true。
            flag = true;

            // 喚醒所有等待執行緒(包括本方執行緒)。
            this.notifyAll();
        }
        finally
        {
            // 釋放鎖。
            lock.unlock();
        }
    }

    // 提供獲取一個商品的方法
    public void get() // t3
    {
        lock.lock();
        try
        {
            while (!flag)
                try{this.wait();}catch(InterruptedException e){ } // t2(等待)、t3(等待)
            System.out.println(Thread.currentThread().getName() + ".......消費者......." + this.name); // t2、麵包1

            // 將標記改為false。
            flag = false;
            // 喚醒所有等待執行緒(包括本方執行緒)。
            this.notifyAll();
        }
        finally
        {
            lock.unlock();
        }

    }
}

// 生成者
class Producer implements Runnable
{
    private Res r; 
    Producer(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
            r.set("麵包");
    }
}

// 消費者
class Consumer implements Runnable
{
    private Res r;
    Consumer(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
            r.get();
    }
}

class NewProducerConsumerDemo
{
    public static void main(String[] args) 
    {
        // 1、建立資源
        Res r = new Res();
        // 2、建立兩個任務。
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        // 3、建立執行緒
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);

        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

替換完之後，發現執行以上程式會報告如下異常，我截圖如下。 在這裡插入圖片描述 究其原因就是wait()沒有了同步區域，沒有了所屬的同步鎖。同步升級了，其中鎖已經不再是任意物件了，而是Lock型別的物件，那麼和任意物件繫結的監視器方法，是不是也升級了，有了專門和Lock型別鎖的繫結的監視器方法呢？通過查閱API幫助文件，可知Condition介面替代了Object類中的監視器方法。以前是監視器方法封裝到了每一個物件中，現在是將監視器方法封裝到了Condition物件中，方法名為await()、signal()、signalAll()。那麼問題又來了，監視器物件Condition如何和Lock繫結呢？答案是可以通過Lock介面的newCondition()方法完成。 按照上面的分析，我將多個生產者和消費者案例的程式碼修改如下：

import java.util.concurrent.locks.*;
// 描述資源
class Res
{
    private String name; // 資源名稱
    private int count = 1; // 資源編號
    // 建立新Lock
    private Lock lock = new ReentrantLock();
    // 建立和Lock介面繫結的監視器物件
    private Condition con = lock.newCondition();
    // 定義標記。
    private boolean flag;
    // 提供了給商品賦值的方法
    public void set(String name) //
    {
        // 獲取鎖。
        lock.lock();

        try
        {
            while (flag) // 判斷標記為true，就執行wait()等待。為false，就生產。
                try{con.await();}catch(InterruptedException e){ } // t0(等待)、t1(等待)
            this.name = name + "--" + count; // 麵包1、麵包2、麵包3

            count++; // 4
            System.out.println(Thread.currentThread().getName() + "...生產者..." + this.name); // t0、麵包1  t0、麵包2、t1、麵包3
            // 生產完畢，將標記改為true。
            flag = true;

            // 喚醒所有等待執行緒(包括本方執行緒)。
            // this.notifyAll();
            con.signalAll();
        }
        finally
        {
            // 釋放鎖。
            lock.unlock();
        }
    }

    // 提供獲取一個商品的方法
    public void get() // t3
    {
        lock.lock();
        try
        {
            while (!flag)
                try{con.await();}catch(InterruptedException e){ } // t2(等待)、t3(等待)
            System.out.println(Thread.currentThread().getName() + ".......消費者......." + this.name); // t2、麵包1

            // 將標記改為false。
            flag = false;
            // 喚醒所有等待執行緒(包括本方執行緒)。
            // this.notifyAll();
            con.signalAll();
        }
        finally
        {
            lock.unlock();
        }

    }
}

// 生成者
class Producer implements Runnable
{
    private Res r; 
    Producer(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
            r.set("麵包");
    }
}

// 消費者
class Consumer implements Runnable
{
    private Res r;
    Consumer(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
            r.get();
    }
}

class NewProducerConsumerDemo
{
    public static void main(String[] args) 
    {
        // 1、建立資源
        Res r = new Res();
        // 2、建立兩個任務。
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        // 3、建立執行緒
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);

        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

改完，執行以上程式，雖然執行沒問題，但是問題依舊，一樣喚醒了本方執行緒，效率仍舊低下！接下來我們就要看看如何真正解決多生產多消費的低效率問題了。 經過上面一步一步地分析，到這裡，我們差不多可以寫出真正解決多生產多消費效率低問題的程式了，現將程式碼貼出如下，以供大家參考。

import java.util.concurrent.locks.*;
// 描述資源
class Res
{
    private String name; // 資源名稱
    private int count = 1; // 資源編號
    // 建立新Lock
    private Lock lock = new ReentrantLock();

    // 建立和Lock介面繫結的監視器物件。建立兩個。
    // 生產者監視器
    private Condition producer_con = lock.newCondition();
    // 消費者監視器
    private Condition consumer_con = lock.newCondition();
    // 定義標記。
    private boolean flag;
    // 提供了給商品賦值的方法
    public void set(String name) //
    {
        // 獲取鎖。
        lock.lock();

        try
        {
            while (flag) // 判斷標記為true，就執行wait()等待。為false，就生產。
                try{producer_con.await();}catch(InterruptedException e){ } // t0(等待)、t1(等待)
            this.name = name + "--" + count; // 麵包1、麵包2、麵包3

            count++; // 4
            System.out.println(Thread.currentThread().getName() + "...生產者..." + this.name); // t0、麵包1  t0、麵包2、t1、麵包3
            // 生產完畢，將標記改為true。
            flag = true;

            // 生產完畢，應該喚醒一個消費者來消費。
            consumer_con.signal();
        }
        finally
        {
            // 釋放鎖。
            lock.unlock();
        }
    }

    // 提供獲取一個商品的方法
    public void get() // t3
    {
        lock.lock();
        try
        {
            while (!flag)
                try{consumer_con.await();}catch(InterruptedException e){ } // t2(等待)、t3(等待)
            System.out.println(Thread.currentThread().getName() + ".......消費者......." + this.name); // t2、麵包1

            // 將標記改為false。
            flag = false;
            // 消費完後，應該喚醒一個生產者來生產。
            producer_con.signal();
        }
        finally
        {
            lock.unlock();
        }

    }
}

// 生成者
class Producer implements Runnable
{
    private Res r; 
    Producer(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
            r.set("麵包");
    }
}

// 消費者
class Consumer implements Runnable
{
    private Res r;
    Consumer(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
            r.get();
    }
}

class NewProducerConsumerDemo
{
    public static void main(String[] args) 
    {
        // 1、建立資源
        Res r = new Res();
        // 2、建立兩個任務。
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        // 3、建立執行緒
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);

        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

相關推薦

第二十二講 多執行緒——多執行緒間的通訊——多個生產者和消費者的升級解決方案

這裡我也是採用循序漸進的方式來講解JDK1.5版本中提供的多執行緒升級解決方案，希望能更加容易地讓大家接受。 為了解決多生產多消費的效率低下這一核心問題，在這兒我就告訴大家勢必要用到JDK1.5中jav

第二十一講 多執行緒——多執行緒間的通訊——多個生產者和消費者

首先，試著思考一下執行如下程式，看會得出什麼結果。 // 描述資源 class Res { private String name; // 資源名稱 private int count = 1; // 資源編號 // 定義標記。

JAVA多執行緒wait與notify詳細解析（由生產者和消費者案例引出）

生產者和消費者這個關係是個經典的多執行緒案例。現在我們編寫一個Demo來模擬生產者和消費者之間的關係。 假如有兩個類，一個是資料生產者類DataProvider，另一個是資料消費者類DataConsumer，這兩個類同時對資料類Data進行操作，生產者類負責生產資料，消費者類負責消費資料，下面是

MIT 線性代數導論 第二十二講：矩陣對角化和冪

本講的主要內容 對角化矩陣的概念以及方法 計算矩陣的冪的對角化方法 幾個例子 對角化矩陣、計算矩陣的冪 對於一個有 nnn 個不同特徵向量（其實就是說所有的特徵值均不同）的矩陣 AAA，講它的 nnn 個特徵向量組成一個矩陣 SSS ，如果我們計算 ASAS

halcon第二十二講：相機標定原理

1、座標系的轉換 1.1 世界座標系 世界座標系（world coordinate），也稱為測量座標系，是一個三維直角座標系，以其為基準可以描述相機和待測物體的空間位置。世界座標系的位置可以根據實際情況自由確定。 1.2 相機座標系  相機座標系（camera

python 學習第二十二天（程序和執行緒）

程序 程序就是一個程式在一個數據集上的一次動態執行過程。 程序一般由程式、資料集、程序控制塊三部分組成。 我們編寫的程式用來描述程序要完成哪些功能以及如何完成； 資料集則是程式在執行過程中所需要使用的資源； 程序控制塊用來記錄程序的外部特徵，描述程序的執行變化過程，系統可以利

菜雞的Java課筆記 第二十二 物件多型性

本次只是圍繞著多型性的概念來進行講解，但是所講解的程式碼與實際的開發幾乎沒有關係，而且多型一定是在繼承性的基礎上才可以操作的，        而本次將使用類繼承的關係來描述多型的性質，實際的開發中不會出現普通類的繼承關係（一個已經完善的類不應該再被繼

java多執行緒同步以及執行緒間通訊詳解&消費者生產者模式&死鎖&Thread.join()（多執行緒程式設計之二）

從執行結果，我們就可以看出我們4個售票視窗同時賣出了1號票，這顯然是不合邏輯的，其實這個問題就是我們前面所說的執行緒同步問題。不同的執行緒都對同一個資料進了操作這就容易導致資料錯亂的問題，也就是執行緒不同步。那麼這個問題該怎麼解決呢？在給出解決思路之前我們先來分析一下這個問題是怎麼產生的？我們宣告一個執行緒類

MIT 線性代數導論 第二十四講~二十九講的概念梳理

最後的這幾講很多是介紹一些概念以及應用和複習總結，所以簡單記錄下一下，不再詳細展開。 主要內容有： 馬爾可夫矩陣以及傅立葉級數的概念 實對稱矩陣以及正定矩陣的介紹 相似矩陣的概念 正定矩陣的概念 馬爾可夫矩陣 馬爾可夫矩陣（Markov Matri

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

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

Java多執行緒基礎之手撕生產者和消費者模式

問題描述 資料結構： 生產者/消費者 快取區(共享資源) 規則： 生產/消費者同時操作快取區。 當快取區為空的時候，消費者不能消費，即消費者阻塞。 當快取區為滿的時候，生產者不能生產，即生產者阻

深入理解 Java 虛擬機器（十二）Java 記憶體模型與執行緒

執行緒安全 Java 語言中的執行緒安全 根據執行緒安全的強度排序，Java 語言中各種操作共享的資料可以分為 5 類：不可變、絕對執行緒安全、相對執行緒安全、執行緒相容、執行緒對立。 不可變 不可變的物件一定是執行緒安全的，如果共享資料是一個基本資料型別，那麼

生產者和消費者多執行緒模擬

package yn.ngems.cn; class Message{     private String title;     private String content;     private boo

[多執行緒] 執行緒同步鎖 Lock 的使用 ReentrantLock (生成者和消費者)

文章目錄 Lock 常用方法 Lock 和 ReentrantLock 使用案例 Lock 介面簡介: ReentrantLock 簡介: 註釋來自JDK1.6文件 Lock 常用方法

Java 多執行緒 生產者和消費者 佇列

    wait()和notifyAll()方法以一種非常低階的方式解決了任務互操作問題，即每次互動時都握手。在許多情況下，你可以瞄向更高的抽象級別，使用同步佇列來解決任務協作問題，同步佇列在任何時刻都只允許一個任務插入或移除元素。在java.util.concurrent

linux多執行緒學習（七）——實現“生產者和消費者”

在上一篇文章中，利用訊號量實現了執行緒間的互斥，這一篇將要利用訊號量的互斥同步機制來實現一個經典例項，就是“生產者和消費者”。 1、簡單描述生產者和消費者的問題。 有一個緩衝區和兩個執行緒：生產者和消費者。生產者把產品放入緩衝區，而消費者從緩衝區中拿走。當緩衝區滿時，生產者必

C++ Boost 多執行緒(九)，生產者和消費者問題

#include <iostream> #include <boost/thread.hpp> using namespace std; class Account { pu

深入理解Java虛擬機器JVM高階特性與最佳實踐閱讀總結—— 第十二章 Java記憶體模型與執行緒

Java記憶體模型JMM，主要目標是定義程式中各個變數的訪問規則，即在虛擬機器中將變數儲存到記憶體和從記憶體讀取變數的底層細節，這裡的變數不包括執行緒私有的變數，如區域性引數；記憶體模型規定所有變數儲存在主記憶體；每個執行緒都有自己的工作記憶體，其中儲存了該執行緒用到的變數

Java多執行緒-生產者和消費者

標籤（空格分隔）： java thread 簡介： 隨著作業系統的不斷更新迭代，多執行緒程式設計已經變的十分常見，java虛擬機器的多執行緒一般也是建立在作業系統本地native執行緒之上的，從而不必自己管理執行緒間的切換，直接交由本機作業系統進行排程和

多執行緒用互斥鎖和條件變數實現生產者和消費者-------迴圈任務佇列

互斥鎖與條件變數簡介 在多執行緒的環境中，全域性變數會被各執行緒共享，因此在操作全域性變數的時候需要採用鎖機制，在linux裡最常用的鎖就是互斥鎖，互斥鎖使用方法如下 <pre name="code" class="cpp">//執行緒A pthread_mut