2. 程式人生 > >第3章 執行緒間通訊

第3章 執行緒間通訊

阿新 • • 發佈：2019-02-12

等待/通知機制

執行緒於執行緒之間不是獨立的個體，它們彼此之間可以相互通訊與協作。

等待/通知機制的實現

方法 wait() 的作用是使當前執行程式碼的執行緒進行等待，wait() 方法使 Object 類的方法，該方法將當前執行緒置入“預執行佇列中”，並且在 wait() 所執行程式碼處停止執行，知道接到通知或被中斷為止。在呼叫 wait() 之前，執行緒必須獲得該物件的物件級別鎖。在執行 wait() 方法後，當前執行緒釋放鎖。
方法 notify() 也要在同步方法或同步塊中呼叫，即在呼叫前，執行緒也必須獲得該物件的物件級別鎖。該方法用來通知那些可能等待該物件的物件鎖的其他執行緒，如果由多個等待執行緒，則由多執行緒規劃器隨機挑選出一個呈 wait() 狀態的執行緒，對其發出通知 notify，並使它等待獲取該物件的物件鎖。
wait 使執行緒停止執行，而 notify 使停止的執行緒繼續執行。

public class MyThread1 extends Thread {
    private Object lock;

    public MyThread1(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock){
                System.out.println("開始 wait time = " + System.
 
currentTimeMillis());
                lock.wait();
                System.out.println("結束 wait time = " + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyThread2 extends Thread {
    private Object lock;
 


    public MyThread2(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println("開始 notify time = " + System.currentTimeMillis());
            lock.notify();
            System.out.println("結束 notify time = " + System.currentTimeMillis());
        }
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            Object lock = new Object();
            MyThread1 t1 = new MyThread1(lock);
            t1.start();
            Thread.sleep(3000);
            MyThread2 t2 = new MyThread2(lock);
            t2.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

執行結果：
開始 wait time = 1543231514059
開始 notify time = 1543231517064
結束 notify time = 1543231517064
結束 wait time = 1543231517064

public class MyList {
    private static List list = new ArrayList();
    public static void add(){
        list.add("anyString");
    }
    public static int size(){
        return list.size();
    }
}

public class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock){
                if(MyList.size() != 5){
                    System.out.println("wait begin " + System.currentTimeMillis());
                    lock.wait();
                    System.out.println("wait end " + System.currentTimeMillis());
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadB extends Thread {
    private Object lock;

    public ThreadB(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock){
                for (int i = 0; i < 10; i++) {
                    MyList.add();
                    if(MyList.size() == 5){
                        //根據執行結果來看，執行notify以後，並不是立即釋放鎖，因為這個方法還在繼續執行
                        lock.notify();
                        System.out.println("已發出通知！");
                    }
                    System.out.println("添加了 " + (i+1) + "個元素");
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        try {
            Object lock = new Object();
            ThreadA threadA = new ThreadA(lock);
            threadA.start();
            Thread.sleep(50);
            ThreadB threadB = new ThreadB(lock);
            threadB.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

關鍵字 synchronized 可以將任何一個 Object 物件作為同步物件，而 Java 為每個 Object 都實現了 wait() 和 notify() 方法。它們必須用在被 synchronized 同步的 Object 臨界區內。通過呼叫 wait() 方法可以使處於臨界區內的執行緒進入等待狀態，同時釋放被同步的物件鎖。而 notify 操作可以喚醒一個因呼叫了 wait 操作而處於阻塞狀態中的執行緒，使其進入就緒狀態。
notify() 方法可以隨機喚醒等待佇列中等待同一個資源的一個執行緒，並使該執行緒退出等待佇列，進入可執行狀態，也就是 notify() 方法僅通知一個執行緒。
notifyAll() 方法可以使所有正在等待佇列中等待同一資源的全部執行緒從等待狀態退出，進入可執行狀態。此時，優先順序最高的那個執行緒最先執行，但也有可能隨機執行，這取決於 JVM 虛擬機器的實現。

在這裡插入圖片描述

  1. 新建立一個執行緒後再呼叫它的 start() 方法，系統會為此執行緒分配 CPU 資源，使其處於 Runnable（可執行）狀態，這是一個準備執行的階段。如果執行緒搶到 CPU 資源，該執行緒就處於 Running（執行）狀態。
  2. Running 狀態和 Runnable 狀態可相互切換，因為有可能執行緒執行一段時間以後，有其他優先順序高的執行緒搶佔了 CPU 資源，此時執行緒就從 Running 變成了 Runnable。
    執行緒進入 Runnable 狀態大體分為 5 中情況：
  • 呼叫 sleep() 方法後經過的時間超過了指定的休眠時間
  • 執行緒呼叫的阻塞 IO 已經返回，阻塞方法執行完畢
  • 執行緒成功地獲得了試圖同步的監視器
  • 執行緒正在等待某個通知，其他執行緒發出了通知
  • 處於掛起狀態的執行緒呼叫了 resume 恢復方法
  1. Blocked 是阻塞的意思，例如遇到一個 IO 操作，此時 CPU 處於空閒狀態，可能轉而會把 CPU 時間分配給其他執行緒，這時也稱之為暫停狀態。
    出現阻塞大體分為 5 中情況：
  • 執行緒呼叫 sleep 方法，主動放棄佔用的處理器資源
  • 執行緒呼叫了阻塞的 IO 方法，在方法返回前，該執行緒被阻塞
  • 執行緒試圖獲得一個同步監視器，但該同步監視器正在被其他執行緒所持有
  • 執行緒等待某個通知
  • 程式呼叫了 suspend 方法將該執行緒掛起
  1. run() 方法執行結束後進入銷燬階段，整個執行緒執行完畢。

每個所物件都有兩個佇列，一個是就緒佇列，一個是阻塞佇列。就緒佇列儲存了將要得鎖的執行緒，阻塞佇列儲存了被阻塞的執行緒。

方法 wait() 鎖釋放與 notify() 鎖不釋放

當方法 wait() 被執行後，鎖自動釋放，但執行完 notify() 方法，鎖卻不自動釋放。

wait() 方法被執行以後，鎖自動釋放：

public class Service {
    public void testMethod(Object lock){
        try {
            synchronized (lock){
                System.out.println(Thread.currentThread().getName() + "begin wait");
                lock.wait();
                System.out.println("end wait");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

public class ThreadB extends Thread {
    private Object lock;

    public ThreadB(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

public class Test {
    public static void main(String[] args) {
        Object lock = new Object();
        ThreadA a = new ThreadA(lock);
        a.start();
        ThreadB b = new ThreadB(lock);
        b.start();
    }
}

執行結果：
Thread-0begin wait
Thread-1begin wait

方法 notify() 執行後，不釋放鎖：

public class Service {
    public void testMethod(Object lock){
        try {
            synchronized (lock){
                System.out.println("begin wait ThreadName = " + Thread.currentThread().getName());
                lock.wait();
                System.out.println("end wait ThreadName = " + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void synNotifyMethod(Object lock){
        try {
            synchronized (lock){
                System.out.println("begin notify ThreadName = " + Thread.currentThread().getName() +
                        "time = " + System.currentTimeMillis());
                //lock.notify()這句程式碼執行完畢以後還是不會釋放鎖，要等到notify所在的程式碼塊中的程式碼全部執行完畢以後才會釋放鎖
                lock.notify();
                Thread.sleep(5000);
                System.out.println("end notify ThreadName = " + Thread.currentThread().getName() +
                        "time = " + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread {
    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }
}

public class NotifyThread extends Thread{
    private Object lock;

    public NotifyThread(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.synNotifyMethod(lock);
    }
}

public class synNotifyMethodThread extends Thread {
    private Object lock;

    public synNotifyMethodThread(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.synNotifyMethod(lock);
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException{
        Object lock = new Object();
        ThreadA threadA = new ThreadA(lock);
        threadA.start();
        NotifyThread notifyThread = new NotifyThread(lock);
        notifyThread.start();
        synNotifyMethodThread c = new synNotifyMethodThread(lock);
        c.start();
    }
}

只通知一個執行緒

呼叫 notify() 一次只隨機通知一個執行緒進行喚醒

相關推薦

第3章 執行緒間通訊

等待/通知機制 執行緒於執行緒之間不是獨立的個體，它們彼此之間可以相互通訊與協作。 等待/通知機制的實現 方法 wait() 的作用是使當前執行程式碼的執行緒進行等待，wait() 方法使 Object 類的方法，該方法將當前執行緒置入“預執行佇列中”，並且在

【Java多執行緒程式設計核心技術】第三章 執行緒間通訊

等待/通知機制 public final native void wait(long timeout) throws InterruptedException; /* @throws IllegalMonitorStateException if the current th

第三章：執行緒間通訊

一句話總結wait和notify: wait使執行緒停止執行， 而notify使停止的執行緒繼續執行。 wait()執行後，執行緒進入等待執行緒佇列，釋放鎖。notify()執行後，並不立即釋放鎖，後面語句要執行完才釋放。 關鍵字synchronized

python多執行緒————3、多執行緒間通訊：共享變數，queue

1、共享變數 #通過共享變數 import time import threading url_list = [] def get_detail_html(): global url_list while True: if len(url_list):

第2章 執行緒與鎖-2.3 超越內建鎖

內建鎖的缺點： 一個執行緒因為等待內建鎖而進入阻塞之後，就無法中斷該執行緒了； 嘗試獲得內建鎖時，無法設定超時； 獲得內建鎖，必須使用synchronized塊； synchronized其實是一個語法糖，等價於 synchronized(this

java.util.concurrent包(3)-執行緒間通訊wait/notify和await/signal

1 wait和notify 當呼叫wait()方法時執行緒會放棄物件鎖，進入等待此物件的等待鎖定池，只有針對此物件呼叫notify()方法後本執行緒才進入物件鎖定池準備 Object的方法：void notify(): 喚醒一個正在等待該物件的執行緒。void noti

【JAVA併發第三篇】執行緒間通訊

# 執行緒間的通訊 JVM在執行時會將自己管理的記憶體區域，劃分為不同的資料區，稱為執行時資料區。每個執行緒都有自己私有的記憶體空間，如下圖示： ![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20210120165755791.jpg?x-oss-process=imag

RT-Thread學習筆記3-執行緒間通訊 & 定時器

[toc] *** ## 1. 事件集的使用 單個指定事件喚醒執行緒，任意事件喚醒執行緒，多個指定事件一起喚醒執行緒。訊號量主要用於“一對一”的執行緒同步，當需要“一對多”、“多對一”、“多對多”的同步時，就需要事件集來處理了。RT-Thread中的事件集用一個32位無符號整型變數來表示，變數中的一個位代表

34-多執行緒--死鎖+執行緒間通訊+等待喚醒機制+多生產者多消費者問題

一、死鎖 1、死鎖的常見情形之一：同步的巢狀 說明：同步的巢狀，至少得有兩個鎖，且第一個鎖中有第二個鎖，第二個鎖中有第一個鎖。eg：同步程式碼塊中有同步函式，同步函式中有同步程式碼塊。下面的例子，同步程式碼塊的鎖是obj，同步函式的鎖是this。t1執行緒先執行同步程式碼塊，獲取鎖obj，需

執行緒間通訊的訊息機制的Message和Handler

Message是訊息機制的資訊載體，開發人員可以在Message物件中封裝資料，封裝資料的方式有： 1）setData(),在Message中封裝Bundle型別的資料，在接收方使用getData()獲取該Bundle物件。 2）arg1屬性，int型別，用於封裝int型別變數 3）ar

Java利用wait和notify實現執行緒間通訊

       Java的Object類提供了wait和notify方法用於實現執行緒間通訊(因為所有的java類都繼承了Object類，所以所有的java類都有這兩個方法)。這兩個方法在Object類中籤名如下： pu

JavaSE習題 第八章 執行緒（未完成）

問答題 1.執行緒和程序是什麼關係？ 　　程序是程式的一次動態執行，對應了從程式碼載入，執行至執行完畢的一個完整的過程 　　執行緒是比程序更小的執行單位，一個程序在其執行過程中可以產生多個執行緒，形成多條執行線索 2.執行緒有幾種狀態？ 　　4種，新建，執行，中斷，死亡 3.引起執行緒中斷的常見原

第四章—執行緒、對稱多處理和微核心【計算機作業系統】

4.1 表3.5列出了在一個沒有執行緒的作業系統中程序控制塊的基本元素。對於多執行緒系統，這些元素中那些可能屬於執行緒控制塊，那些可能屬於程序控制塊？ 這對於不同的系統來說通常是不同的，但一般來說，程序是資源的所有者，而每個執行緒都有它自己的執行狀態。關於表3.5中的每一項的一些結論如

Java併發程式設計（10）:使用wait/notify/notifyAll實現執行緒間通訊的幾點重要說明

在Java中，可以通過配合呼叫Object物件的wait（）方法和notify（）方法或notifyAll（）方法來實現執行緒間的通訊。線上程中呼叫wait（）方法，將阻塞等待其他執行緒的通知（其他執行緒呼叫notify（）方法或notifyAll（）方法），線上程中呼叫notify（）方法或notifyAl

Java執行緒間通訊--管道

Java提供了多種輸入輸出流用於對資料進行操作，其中管道流pipeStream是一種特殊的流，用於在不同執行緒間直接傳送資料。 pis.read的時候，如果管道內沒有資料，會阻塞。 public class PipeStreamMain { public static voi

Java多執行緒學習筆記15之執行緒間通訊

詳細程式碼見:github程式碼地址   本節內容: 1）ThreadLocal類的使用     JDK文件及方法翻譯     InheritableThreadLocal的使用   5.

Java多執行緒學習筆記14之執行緒間通訊

詳細程式碼見:github程式碼地址   本節內容: 1) 實戰 等待/通知之交叉備份 2) 方法join的使用(Jdk文件翻譯及原始碼解析)     join()及join(long)的使用和實現原理   &nbs

Java多執行緒學習筆記13之執行緒間通訊

詳細程式碼見:github程式碼地址   本節內容: 1)  生產者消費者模型     多個生產者和多個消費者: 操作值假死及解決     多個生產者和多個消費者: 操作棧假死及解決 2) 通過管

RTthread學習筆記————第4章 執行緒管理

什麼是執行緒 執行緒，有時被稱為輕量級程序(Lightweight Process，LWP），是程式執行流的最小單元。一個標準的執行緒由執行緒ID，當前指令指標(PC），暫存器集合和堆疊組成。 RT-Thread 的執行緒排程器是搶佔式的，主要的工作

安卓多執行緒間通訊和多程序之間通訊有什麼不同?分別怎麼實現?

**當一個程式第一次啟動的時候，Android會去動一個Linux進行和一個主執行緒，預設情況下，所有改程式元件都將在該程序和執行緒中 執行，同時Android會為每個應用程式分配一個單獨的Linux使用者，Android會盡量保留一個正在執行的程序，只在記憶體資源出現不足時，Andro