腳本之家服務器常用軟件

快捷導航

java使用wait和notify實現(xiàn)線程通信

更新時間：2023年10月07日 10:40:53 作者：終有救贖

這篇文章主要為大家詳細介紹了java如何使用wait和notify實現(xiàn)線程之間通信,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下

一. 為什么需要線程通信

線程是并發(fā)并行的執(zhí)行，表現(xiàn)出來是線程隨機執(zhí)行，但是我們在實際應用中對線程的執(zhí)行順序是有要求的，這就需要用到線程通信

線程通信為什么不使用優(yōu)先級來來解決線程的運行順序？

總的優(yōu)先級是由線程pcb中的優(yōu)先級信息和線程等待時間共同決定的，所以一般開發(fā)中不會依賴優(yōu)先級來表示線程的執(zhí)行順序

看下面這樣的一個場景：面包房的例子來描述生產(chǎn)者消費者模型

有一個面包房，里面有面包師傅和顧客，對應我們的生產(chǎn)者和消費者，而面包房有一個庫存用來存儲面包，當庫存滿了之后就不在生產(chǎn)，同時消費者也在購買面包，當庫存面包賣完了之后，消費者必須等待新的面包生產(chǎn)出來才能繼續(xù)購買

分析： 對于何時停止生產(chǎn)何時停止消費就需要應用到線程通信來準確的傳達生產(chǎn)和消費信息

二. wait和notify方法

wait()：讓當前線程持有的對象鎖釋放并等待

wait(long timeout)：對應的參數(shù)是線程等待的時間

notify()：喚醒使用同一個對象調(diào)用wait進入等待的線程，重新競爭對象鎖

notifyAll()：如果有多個線程等待，notifyAll是全部喚醒，notify是隨機喚醒一個

注意：

這幾個方法都屬于Object類中的方法

必須使用在synchronized同步代碼塊/同步方法中

哪個對象加鎖，就是用哪個對象wait，notify

調(diào)用notify后不是立即喚醒，而是等synchronized結(jié)束以后，才喚醒

1. wait()方法

調(diào)用wait方法后：

使執(zhí)行當前代碼的線程進行等待（線程放在等待隊列）
釋放當前的鎖
滿足一定條件時被喚醒，重新嘗試獲取鎖

wait等待結(jié)束的條件：

其他線程調(diào)用該對象的notify方法
wait等待時間超時（timeout參數(shù)來指定等待時間）
其他線程調(diào)用interrupted方法，導致wait拋出InterruptedException異常

2. notify()方法

當使用wait不帶參數(shù)的方法時，喚醒線程等待就需要使用notify方法

這個方法是喚醒那些等待該對象的對象鎖的線程，使他們可以重新獲取該對象的對象鎖
如果有多個線程等待，則由線程調(diào)度器隨機挑選出一個呈wait 狀態(tài)的線程(不存在先來后到)
在notify()方法后，當前線程不會馬上釋放該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出同步代碼塊之后才會釋放對象鎖

3. notifyAll()方法

該方法和notify()方法作用一樣，只是喚醒的時候，將所有等待的線程都喚醒

notify()方法只是隨機喚醒一個線程

三. 使用wait和notify實現(xiàn)面包房業(yè)務

前提說明：

有2個面包師傅，面包師傅一次可以做出兩個面包

倉庫可以存儲100個面包

有10個消費者，每個消費者一次購買一個面包

注意：

消費和生產(chǎn)是同時并發(fā)并行進行的，不是一次生產(chǎn)一次消費

實現(xiàn)代碼：

public class Bakery {
    private static int total;//庫存
    public static void main(String[] args) {
        Producer producer = new Producer();
        for(int i = 0;i < 2;i++){
            new Thread(producer,"面包師傅-"+(i-1)).start();
        }
        Consumer consumer = new Consumer();
        for(int i = 0;i < 10;i++){
            new Thread(consumer,"消費者-"+(i-1)).start();
        }
    }
    private static class Producer implements Runnable{
        private int num = 3; //生產(chǎn)者每次生產(chǎn)三個面包
        @Override
        public void run() {
            try {
                while(true){ //一直生產(chǎn)
                    synchronized (Bakery.class){
                        while((total+num)>100){ //倉庫滿了，生產(chǎn)者等待
                            Bakery.class.wait();
                        }
                        //等待解除
                        total += num;
                        System.out.println(Thread.currentThread().getName()+"生產(chǎn)面包，庫存："+total);
                        Thread.sleep(500);
                        Bakery.class.notifyAll(); //喚醒生產(chǎn)
                    }
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private static class Consumer implements Runnable{
        private int num = 1; //消費者每次消費1個面包
        @Override
        public void run() {
            try {
                while(true){ //一直消費
                    synchronized (Bakery.class){
                        while((total-num)<0){ //倉庫空了，消費者等待
                            Bakery.class.wait();
                        }
                        //解除消費者等待
                        total -= num;
                        System.out.println(Thread.currentThread().getName()+"消費面包，庫存："+total);
                        Thread.sleep(500);
                        Bakery.class.notifyAll(); //喚醒消費
                    }
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

部分打印結(jié)果：

四. 阻塞隊列

阻塞隊列是一個特殊的隊列，也遵循“先進先出”的原則，它是線程安全的隊列結(jié)構(gòu)

特性： 典型的生產(chǎn)者消費者模型，一般用于做任務的解耦和消峰

隊列滿的時候，入隊列就堵塞等待（生產(chǎn)），直到有其他線程從隊列中取走元素

隊列空的時候，出隊列就堵塞等待（消費），直到有其他線程往隊列中插入元素

1. 生產(chǎn)者消費者模型

生產(chǎn)者消費者模式就是通過一個容器來解決生產(chǎn)者和消費者的強耦合問題

生產(chǎn)者和消費者彼此之間不直接通信，而通過阻塞隊列來進行通信，所以生產(chǎn)者生產(chǎn)完數(shù)據(jù)之后等待消費者處理，直接扔給阻塞隊列，消費者不找生產(chǎn)者要數(shù)據(jù)，而是直接從阻塞隊列里取

阻塞隊列就相當于一個緩沖區(qū)，平衡了生產(chǎn)者和消費者的處理能力阻塞隊列也能使生產(chǎn)者和消費者之間解耦

上述面包房業(yè)務的實現(xiàn)就是生產(chǎn)者消費者模型的一個實例

2. 標準庫中的阻塞隊列

在 Java 標準庫中內(nèi)置了阻塞隊列，如果我們需要在一些程序中使用阻塞隊列, 直接使用標準庫中的即可

BlockingQueue 是一個接口. 真正實現(xiàn)的類是 LinkedBlockingQueue

put 方法用于阻塞式的入隊列, take 用于阻塞式的出隊列

BlockingQueue 也有 offer, poll, peek 等方法, 但是這些方法不帶有阻塞特性

        BlockingDeque<String> queue = new LinkedBlockingDeque<>();
        queue.put("hello");
        //如果隊列為空，直接出出隊列就會阻塞
        String ret = queue.take();
        System.out.println(ret);

3. 阻塞隊列的模擬實現(xiàn)

這里使用數(shù)組實現(xiàn)一個循環(huán)隊列來模擬阻塞隊列

當隊列為空的時候，就不能取元素了，就進入wait等待，當有元素存放時，喚醒
當隊列為滿的時候，就不能存元素了，就進入wait等待，當鈾元素取出時，喚醒

實現(xiàn)代碼：

public class MyBlockingQueue {
    //使用數(shù)組實現(xiàn)一個循環(huán)隊列，隊列里面存放的是線程要執(zhí)行的任務
    private Runnable[] tasks;
    //隊列中任務的數(shù)量，根據(jù)數(shù)量來判斷是否可以存取
    private int count;
    private int putIndex; //存放任務位置
    private int takeIndex; //取出任務位置
    //有參的構(gòu)造方法，表示隊列容量
    public MyBlockingQueue(int size){
        tasks = new Runnable[size];
    }
    //存任務
    public void put(Runnable task){
        try {
            synchronized (MyBlockingQueue.class){
                //如果隊列容量滿了，則存任務等待
                while(count == tasks.length){
                    MyBlockingQueue.class.wait();
                }
                tasks[putIndex] = task; //將任務放入數(shù)組
                putIndex = (putIndex+1) % tasks.length; //更新存任務位置
                count++; //更新存放數(shù)量
                MyBlockingQueue.class.notifyAll(); //喚醒取任務
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //取任務
    public Runnable take(){
        try {
            synchronized (MyBlockingQueue.class){
                //如果隊列任務為空，則取任務等待
                while(count==0){
                    MyBlockingQueue.class.wait();
                }
                //取任務
                Runnable task = tasks[takeIndex];
                takeIndex = (takeIndex+1) % tasks.length; //更新取任務位置
                count--; //更新存放數(shù)量
                MyBlockingQueue.class.notifyAll(); //喚醒存任務
                return task;
            }
        } catch (InterruptedException e) {
           throw new RuntimeException("存放任務出錯",e);
        }
    }
}