Java多線程中的wait/notify通訊模式

時間  2020-12-01
標籤 數據庫 編程 安全 多線程 併發 ide 函數 spa 線程 code 欄目 Java 简体版
原文   原文鏈接

前言

　　最近在看一些JUC下的源碼，更加意識到想要學好Java多線程，基礎是關鍵，好比想要學好ReentranLock源碼，就得掌握好AQS源碼，而AQS源碼中又有不少Java多線程經典的一些應用；再好比看了線程池的核心源碼實現，又學到了不少核心實現，其實這些均可以提出來慢慢消化並變成本身的知識點，今天這個Java等待/通知模式實際上是Thread.join()實現的關鍵，還有線城市工做線程中線程跟線程之間的通訊的核心所在，故在此爲了加深理解，作此記錄！數據庫

　　參考資料《Java併發編程藝術》（電子PDF版），有須要的朋友的能夠私信或者評論編程

 

 

1、什麼是Java線程的等待/通知模式

一、等待/通知模式概述

　　首先先介紹下官方的一個正式的介紹：安全

　　等待/通知機制，是指一個線程A調用了對象object的wait()方法進入等待狀態，而另外一個線程B調用了對象object的notify或者notifyAll()方法，線程A收到通知後從對象O的wait()方法返回，進而還行後續操做。多線程

　　而個人理解是（舉例說明）：併發

　　假設工廠裏有兩條流水線，某個工做流程須要這兩個流水線配合完成，這兩個流水線分別是A和B，其中A負責準備各類配件，B負責租裝配件以後產出輸出到工做臺。B的工做須要A的配件準備充分，不然就會一直等待A準備好配件，而且A準備好配件後會經過一個開頭通知告訴B我已經準備好了，你那邊不用一直等待了，能夠繼續執行任務了。流程A與流程B就是對應的線程A與線程B之間的通訊，便可以理解爲相互配合，具體也就是「」通知/等待「」機制！ide

二、須要注意的細節　　

　　那麼，咱們都知道超類Object有wait()方法與notify()/notifyAll()方法，在進行正式代碼舉例以前，應該先加深下對這三個方法的理解與一些細節（有一些細節確實容易被忽略）函數

  • 調用wait()方法，會釋放鎖（這一點我想大部分人都知道），線程狀態由RUNNING->WAITNG，當前線程進入對象等待隊列中；
  • 調用notify()/notifyAll()方法不會立馬釋放鎖（這一點我你們人也應該知道，可是何時釋放鎖呢？--------請看下一條），notify()方法是將等待隊列中的線程移到同步隊列中，而notifyAll()則是所有移到同步隊列中，被移出的線程狀態WAITING-->BLOCKED;
  • 當前調用notify()/notifyAll()的線程釋放鎖了纔算釋放鎖，纔有機會喚醒wait線程返回（爲何有才有機會返回呢？------繼續看下一條）
  • 從wait()返回的前提是必須得到調用對象鎖，也就是說notify()與notifyAll()釋放鎖以後，wait()進入BLOCKED狀態，若是其餘線程有競爭當前鎖的話，wait線程繼續爭取鎖資格（很差理解的話，請看下面的代碼舉例）
  • 使用wait()、notify()、notifyAll()方法時須要先調對象加鎖（這多是最容易忽視的點了，至於爲何，請先看了代碼以後，看本篇博文最後補充：wait()、notify()、notifyAll()加鎖的緣由----防止線程即飢餓）

2、代碼舉例

一、結合代碼理解spa

　結合上述的「工廠流程裝配配件併產出的例子」，咱們有兩個線程（流水線）WaitThread與NotifyThread、其中WaitThread是被通知的任務，完成主要的工做（組裝配件完成產品），須要時刻判斷標誌位（開關）；NotifyThread是須要通知的任務，須要對WaitThread進行「監督通知」，兩個配合才能更好完成產品的組裝並輸出。線程

public class WaitNotify {

    static Object lock = new Object();
    static boolean flag = false;
    public static void main(String[] args) {
        new Thread(new WaitThread(), "WaitThread").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new NotifyThread(), "NotifyThread").start();

    }

    /**
     * 流水線A，完成主要任務
     */
    static class WaitThread implements Runnable{
        @Override
        public void run() {
            // 獲取object對象鎖
            synchronized (lock){
                // 條件不知足時一直在等，等另外的線程改變該條件，並通知該wait線程
                while (!flag){
                    try {
                        System.out.println(Thread.currentThread() + " is waiting, flag is "+flag);
                        // wait()方法調用就會釋放鎖，當前線程進入等待隊列。
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // TODO 條件已經知足，不繼續while，完成任務
                System.out.println(Thread.currentThread() + " is running, flag is "+flag);
            }
        }
    }
    /**
     * 流水線B，對開關進行控制，並通知流水線A
     */
    static class NotifyThread implements Runnable{
        @Override
        public void run() {
            // 獲取等wait線程同一個object對象鎖
            synchronized (lock){
                flag = true;
                // 通知wait線程，我已經改變了條件，你能夠繼續返回執行了（返回以後繼續判斷while）
                // 可是此時通知notify()操做並當即不會釋放鎖，而是要等當前線程釋放鎖
                // TODO 我準備好配件了，我須要通知所有的組裝流水線A.....
                lock.notifyAll();
                System.out.println(Thread.currentThread() + " hold lock, notify waitThread and flag is "+flag);
            }
        }
    }
}

運行main函數，輸出：code

Thread[WaitThread,5,main] is waiting, flag is false
Thread[NotifyThread,5,main] hold lock, notify waitThread and flag is true
Thread[WaitThread,5,main] is running, flag is true

車牀流水工做開啓，流水線的開關一開始是關閉的（flag=false），流水線B（NotifyThread）去開啓後，開始自動喚醒流水線A（WaitThread），整個流水線開始工做了......

  • Thread[WaitThread,5,main] is waiting, flag is false： 一開始流水線A發現本身沒有配件可租裝，因此等流水線A準備好配件（這樣是否是以爲特別傻，哈哈哈，真正的流水線不會浪費時間等的，並且會有不少條流水線B準備配件的，這裏只是舉例說明，望理解！）；
  • Thread[NotifyThread,5,main] hold lock, notify waitThread and flag is true：流水線B準備好了配件，開啓開關（flag=ture），並通知流水線A，讓流水線A開始工做；
  • Thread[WaitThread,5,main] is running, flag is true，流水線B收到了通知，再次檢查開關是否開啓了，開啓的話就開始返回繼續完成工做了。

其實結合上述我舉的例子仍是很好理解的，下面是大概的一個粗略時序圖：

　　　　　　　 　　　　

二、擴展理解----wait()返回的前提是得到了鎖

上述已經表達了這個注意的細節：從wait()返回的前提是必須得到調用對象鎖，咱們再增長能競爭lock的同步代碼塊（紅字部分）。

public class WaitNotify {

    static Object lock = new Object();
    static boolean flag = false;
    public static void main(String[] args) {
        new Thread(new WaitThread(), "WaitThread").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new NotifyThread(), "NotifyThread").start();
    }

    /**
     * 流水線A，完成主要任務
     */
    static class WaitThread implements Runnable{
        @Override
        public void run() {
            // 獲取object對象鎖
            synchronized (lock){
                // 條件不知足時一直在等，等另外的線程改變該條件，並通知該wait線程
                while (!flag){
                    try {
                        System.out.println(Thread.currentThread() + " is waiting, flag is "+flag);
                        // wait()方法調用就會釋放鎖，當前線程進入等待隊列。
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // TODO 條件已經知足，不繼續while，完成任務
                System.out.println(Thread.currentThread() + " is running, flag is "+flag);
            }
        }
    }
    /**
     * 流水線B，對開關進行控制，並通知流水線A
     */
    static class NotifyThread implements Runnable{
        @Override
        public void run() {
            // 獲取等wait線程同一個object對象鎖
            synchronized (lock){
                flag = true;
                // 通知wait線程，我已經改變了條件，你能夠繼續返回執行了（返回以後繼續判斷while）
                // 可是此時通知notify()操做並當即不會釋放鎖，而是要等當前線程釋放鎖
                // TODO 我準備好配件了，我須要通知所有的組裝流水線A.....
                lock.notifyAll();
                System.out.println(Thread.currentThread() + " hold lock, notify waitThread and flag is "+flag);
            }
            // 模擬跟流水線B競爭
            synchronized (lock){
                System.out.println(Thread.currentThread() + " hold lock again"); }
        }
    }
}

輸出結果：

Thread[WaitThread,5,main] is waiting, flag is false
Thread[NotifyThread,5,main] hold lock, notify waitThread and flag is true
Thread[NotifyThread,5,main] hold lock again
Thread[WaitThread,5,main] is running, flag is true

 

其中第三條跟第四條順序可能會反着來的，這就是由於lock鎖可能被紅字部分的synchronized代碼塊競爭獲取（這樣wait()方法可能獲取不到lock鎖，不會返回），也可能被waitThread獲取從wait()方法返回。

Thread[WaitThread,5,main] is waiting, flag is false
Thread[NotifyThread,5,main] hold lock, notify waitThread and flag is true
Thread[WaitThread,5,main] is running, flag is true
Thread[NotifyThread,5,main] hold lock again

3、等待/通知模式的應用

一、Thread.join()中源碼應用

Thread.join()做用：當線程A等待thread線程終止以後才從thread.join()返回， 每一個線程終止的前提是前驅線程終止，每一個線程等待前驅線程終止後，才從join方法返回，這裏涉及了等待/通知機制（等待前驅線程結束，接收前驅線程結束通知）。

Thread.join()源碼中，使用while選好判斷前驅線程是否活着，若是前驅線程還活着就一直wait等待，固然若是超時的話就直接返回。

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        // 這裏的while(){wait(millis)} 就是利用等待/通知中的等待模式，只不過加上了超時設置
        if (millis == 0) {
            // while循環,當線程還活着的時候就一直循環等待，直到線程終止
            while (isAlive()) {
                // wait等待
                wait(0);
            }
            // 條件知足時返回
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

二、其它的應用

　　線程池的本質是使用一個線程安全的工做隊列鏈接工做者線程和客戶端線程，客戶端線程將任務放入工做隊列後便返回，而工做者線程則不斷地從工做隊列中取出工做並執行。那麼，在這裏的等待/通知模式的應用就是：

　　工做隊列中線程job沒有的話也就是工做隊列爲空的狀況下，等待客戶端放入工做隊列線程任務，並通知工做線程繼續從工做隊列中獲取線程執行。

　　注：關於線程池的應用源碼這裏不作介紹，由於一時也講不完（本身也尚未徹底消化），先簡單介紹下應用到的地方還有概念。

　　補充：其實數據庫的鏈接池也相似線程池這種工做流程，也會涉及等待/通知模式。

三、等待/通知範式

　　介紹了那麼多應用，這種模式應該有個統一的範式來套用。對的，必然是有的：

　　對於等待者（也能夠稱之爲消費者）：

synchronized (對象lock) {
        while (條件不知足) {
            對象.wait();
        }
        // TODO 處理邏輯
    }

　　對於通知者（也能夠稱之爲生產者）：

 synchronized (對象lock) {
        while (條件知足) {
            改變條件
            對象.notify();
        }
    }

　　注意：實際開發中最好採用的是超時等待/通知模式，在thread.join()源碼方法中完美體現

4、wait()、notify()、notifyAll()使用前須要加鎖的緣由----防止線程即飢餓

（1）其實根據wait()注意事項也能明白，wait()是釋放鎖的，那麼不加鎖哪來釋放鎖！

（2）wait()與notify()或者notifyAll()必須是搭配一塊兒使用的，不然線程調用object.wait()以後，沒有超時機制，也沒有調用notify()或者notifyAll()喚醒的話，就一直處於WAITING狀態，形成調用wait()的線程一直都是飢餓狀態。

（3）因爲第2條的，咱們已知：即使咱們使用了notify()或者notifyAll()去喚醒線程，可是沒有在適當的時機喚醒（好比調用wait()以前就喚醒了），那麼仍然調用wait()線程處於WAITING狀態，因此咱們必須保證wait()方法要麼不執行，要麼就執行完在被喚醒。也就是下列代碼中1那裏不能容許插入調用notify/notifyAll，天然而然就增長synchronized關鍵字，保證wait()操做總體執行不被破壞！

 synchronized (對象lock) {
        while (條件不知足) {
            // 1 這裏若是先執行了notify/notifyAll方法，那麼2執行以後，該線程就一直WAITING
            對象.wait(); // 2
        }
        // TODO 處理邏輯
    }

用圖片展現執行順序就是：

（4）注意synchronized代碼塊中，代碼錯誤或者其它緣由線程終止的話，沒有執行到wait()方法的話，是會自動釋放鎖的，沒必要擔憂會死鎖。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程