So verwenden Sie Wait und Notify, um die Kommunikation zwischen Threads in Java zu implementieren

1. Warum Thread-Kommunikation erforderlich ist

Threads werden gleichzeitig ausgeführt, was zeigt, dass Threads zufällig ausgeführt werden, wir jedoch In In praktischen Anwendungen gibt es Anforderungen an die Ausführungsreihenfolge von Threads, die die Verwendung von Thread-Kommunikation erfordern

Thread-Kommunikation Warum nicht die Priorität verwenden, um die laufende Reihenfolge von Threads zu lösen?

Die Gesamtpriorität wird durch die Prioritätsinformationen in der Thread-Platine und die Thread-Wartezeit bestimmt, daher wird in der allgemeinen Entwicklung nicht auf die Priorität zurückgegriffen, um die Ausführungsreihenfolge von Threads anzugeben

Analyse: Wann die Produktion und wann der Verbrauch gestoppt werden soll, muss Thread-Kommunikation angewendet werden, um Produktions- und Verbrauchsinformationen genau zu übermitteln

2. Methoden warten und benachrichtigen

#🎜 🎜#notify(): Wecken Sie den Thread auf, der dasselbe Objekt verwendet, um Wait aufzurufen, um in den wartenden Thread einzutreten, und konkurrieren Sie erneut um die Objektsperre

notifyAll(): Wenn mehrere Threads warten, notifyAll weckt sie alle und notify weckt zufällig einen auf

Hinweis:

Muss in synchronisierten synchronisierten Codeblöcken/synchronisierten Methoden verwendet werden中

# 🎜🎜#1 🎜#

bewirkt, dass der Thread, der den aktuellen Code ausführt, wartet (der Thread wird in die Warteschlange gestellt)

Aktuelle Sperre aufheben

Werde geweckt, wenn Bestimmte Bedingungen sind erfüllt und es wird erneut versucht, die Sperre zu erhalten Objekt

wait Wartezeit-Timeout (Timeout-Parameter zur Angabe der Wartezeit) Andere Threads rufen die unterbrochene Methode auf, wodurch Wait eine InterruptedException auslöst

2. notify()-Methode

Wenn Sie die Wartemethode ohne Parameter verwenden, müssen Sie sie verwenden, um den Thread aufzuwecken und zu warten.

Diese Methode dient zum Aufwecken Erhöhen Sie die Threads, die auf die Objektsperre des Objekts warten, damit sie die Objektsperre des Objekts erneut erhalten können.

Wenn mehrere Threads warten, wählt der Thread-Scheduler zufällig einen Thread im Wartezustand aus ( Es gibt kein „Wer zuerst kommt, mahlt zuerst“)Nach der notify()-Methode gibt der aktuelle Thread die Objektsperre nicht sofort frei und wartet, bis die notify()-Methode ausgeführt wird Der Thread beendet die Ausführung des Programms, das heißt, die Objektsperre wird nach dem Verlassen des synchronisierten Codeblocks aufgehoben.

3 notifyAll()-Methode

Diese Methode hat den gleichen Effekt Als notify()-Methode werden beim Aufwachen einfach alle wartenden Threads aktiviert.

notify()-Methode weckt einfach zufällig einen Thread auf

3 Verwenden Sie „wait“ und „notify“, um ihn zu implementieren Bäckereibetrieb #🎜 🎜#

Voraussetzung:

#🎜🎜 #Das Lager ist in Ordnung. Lagern Sie 100 Brote

Es gibt 10 Verbraucher, jeder Verbraucher kauft jeweils einen Laib

# 🎜🎜##🎜 🎜#Konsum und Produktion erfolgen gleichzeitig und parallel, nicht eine Produktion und ein Konsum.

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; //生产者每次生产三个面包
        @Override
        public void run() {
            try {
                while(true){ //一直生产
                    synchronized (Bakery.class){
                        while((total+num)>100){ //仓库满了，生产者等待
                            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();
            }
        }
    }
    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();
            }
        }
    }
}

Wenn die Warteschlange leer ist, blockiert sie und wartet (Verbrauch), bis andere Threads Elemente in die Warteschlange einfügen #🎜 🎜##🎜 🎜#1. Produzenten-Verbraucher-Modell

Das Produzenten-Verbraucher-Modell verwendet einen Container, um das Problem der starken Kopplung zwischen Produzenten und Verbrauchern zu lösen.

Produzenten und Verbraucher Sie Kommunizieren Sie nicht direkt miteinander, sondern kommunizieren Sie über blockierende Warteschlangen. Nachdem der Produzent die Daten erzeugt hat, wartet er darauf, dass der Verbraucher sie verarbeitet, und wirft sie direkt in die blockierende Warteschlange. sondern nimmt es direkt aus der Blockierungswarteschlange. Die Blockierungswarteschlange entspricht einem Puffer, der die Verarbeitungsfähigkeiten von Produzenten und Konsumenten ausgleicht.

Blockierung ist in die Java-Standardbibliothekswarteschlange: Wenn wir in einigen Programmen eine Blockierungswarteschlange verwenden müssen, können wir direkt die in der Standardbibliothek verwenden

BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue

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

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

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

3. 阻塞队列的模拟实现

这里使用数组实现一个循环队列来模拟阻塞队列

当队列为空的时候，就不能取元素了，就进入wait等待，当有元素存放时，唤醒

当队列为满的时候，就不能存元素了，就进入wait等待，当铀元素取出时，唤醒

实现代码：

public class MyBlockingQueue {
    //使用数组实现一个循环队列，队列里面存放的是线程要执行的任务
    private Runnable[] tasks;
    //队列中任务的数量，根据数量来判断是否可以存取
    private int count;
    private int putIndex; //存放任务位置
    private int takeIndex; //取出任务位置
 
    //有参的构造方法，表示队列容量
    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; //将任务放入数组
                putIndex = (putIndex+1) % tasks.length; //更新存任务位置
                count++; //更新存放数量
                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--; //更新存放数量
                MyBlockingQueue.class.notifyAll(); //唤醒取任务
                return task;
            }
        } catch (InterruptedException e) {
           throw new RuntimeException("存放任务出错",e);
        }
    }
}

五. wait和sleep的区别（面试题）

相同点：

都可以让线程放弃执行一段时间 

不同点：

☘️wait用于线程通信，让线程在等待队列中等待

☘️sleep让线程阻塞一段时间，阻塞在阻塞队列中

☘️wait需要搭配synchronized使用，sleep不用搭配

☘️wait是Object类的方法，sleep是Thread的静态方法

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Wait und Notify, um die Kommunikation zwischen Threads in Java zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!