Cara menggunakan tunggu dan maklumkan untuk melaksanakan komunikasi antara utas di Jawa

1. Mengapa komunikasi rangkaian diperlukan

Benang dilaksanakan serentak, yang nampaknya merupakan pelaksanaan urutan secara rawak, dalam aplikasi praktikal, kami menggunakan benang komunikasi Perintah pelaksanaan diperlukan, yang memerlukan penggunaan komunikasi benang

Mengapa komunikasi benang tidak menggunakan keutamaan untuk menyelesaikan susunan urutan berjalan?

Keutamaan keseluruhan ditentukan oleh maklumat keutamaan dalam pcb benang dan masa menunggu benang, jadi dalam perkembangan umum, keutamaan tidak bergantung pada untuk menunjukkan susunan pelaksanaan benang

Lihat di bawah Adegan sedemikian: contoh kedai roti untuk menerangkan model pengeluar-pengguna

Terdapat kedai roti dengan pembuat roti dan pelanggan, sepadan dengan pengeluar dan pengguna kami, dan kedai roti mempunyai inventori untuk Untuk menyimpan roti, apabila inventori sudah penuh, ia tidak akan dihasilkan lagi Pada masa yang sama, pengguna juga membeli roti Apabila inventori roti habis dijual, pengguna mesti menunggu roti baru dikeluarkan sebelum boleh terus membeli

Analisis: Untuk apa Bila hendak menghentikan pengeluaran dan bila hendak menghentikan penggunaan, komunikasi benang perlu digunakan untuk menyampaikan maklumat pengeluaran dan penggunaan dengan tepat

2. tunggu dan maklumkan kaedah

tunggu(): biarkan objek yang dipegang oleh benang semasa Lepaskan kunci dan tunggu

tunggu(masa tamat lama): Parameter yang sepadan ialah masa benang menunggu

notify(): Bangunkan thread yang menggunakan objek yang sama untuk memanggil tunggu untuk memasuki utas menunggu, dan bersaing untuk mengunci objek sekali lagi

notifyAll(): Jika terdapat berbilang utas menunggu, notifyAll bangunkan kesemuanya, maklumkan bangunkan satu secara rawak

Nota:

Kaedah ini semuanya tergolong dalam kaedah dalam kelas Objek

mesti digunakan dalam blok kod disegerakkan/kaedah disegerakkan

Objek yang dikunci adalah objek menunggu dan memberitahu

dipanggil ia tidak bangun segera selepas memberitahu, tetapi menunggu sehingga diselaraskan selesai sebelum bangun

1.

Selepas memanggil kaedah tunggu:

Jadikan utas yang melaksanakan kod semasa menunggu (benang diletakkan dalam baris gilir menunggu)

Lepaskan kunci semasa

Berhati-hati apabila syarat tertentu dipenuhi, dan cuba dapatkan kunci itu semula

Syarat untuk menunggu sehingga tamat:

Urutan lain memanggil kaedah pemberitahuan bagi objek

Tunggu masa menunggu tamat (parameter tamat masa untuk menentukan masa menunggu)

Urut lain Memanggil kaedah yang terganggu menyebabkan menunggu untuk membuang InterruptedException

2. kaedah notify()

Apabila menggunakan kaedah tunggu tanpa parameter, anda perlu menggunakan kaedah notify

Kaedah ini adalah untuk membangunkan utas tersebut menunggu untuk kunci objek objek supaya mereka boleh memperoleh semula kunci objek objek

Jika terdapat berbilang utas menunggu, penjadual benang akan secara rawak memilih utas Status tunggu (tidak datang dahulu, dilayan dahulu)

Selepas kaedah notify(), thread semasa tidak akan melepaskan kunci objek serta-merta Ia akan menunggu sehingga thread yang melaksanakan kaedah notify() selesai melaksanakan program, iaitu, keluar dari kod penyegerakan Kunci objek. akan dikeluarkan hanya selepas blok

3 kaedah notifyAll()

Kaedah ini mempunyai fungsi yang sama seperti kaedah notify(), kecuali apabila bangun, semua utas menunggu akan dikejutkan. up

Kaedah notify() hanya membangkitkan thread secara rawak

3 Gunakan tunggu dan maklumkan untuk melaksanakan perniagaan bakeri

Prasyarat:

Ya 2 tukang roti, tukang roti boleh buat dua roti dalam satu masa

Gudang boleh simpan 100 roti

Terdapat 10 pengguna, setiap pengguna membeli satu roti pada satu masa

Nota:

Penggunaan dan pengeluaran dijalankan secara serentak dan selari, bukan satu pengeluaran dan satu penggunaan

Kod pelaksanaan:

Hasil cetakan separa:

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();
            }
        }
    }
}

4. Baris menyekat

Baris gilir menyekat ialah baris gilir khas yang turut mengikuti " prinsip first in, first out" Pada dasarnya, ia adalah struktur baris gilir selamat benang

Ciri-ciri: Model pengeluar-pengguna biasa, biasanya digunakan untuk penyahgandingan tugas dan penyingkiran puncak

Apabila baris gilir penuh, baris gilir akan Sekat dan tunggu (menghasilkan) sehingga utas lain mengambil elemen daripada baris gilir

Apabila baris gilir kosong, sekat dan tunggu (penggunaan) sehingga utas lain memasukkan elemen ke dalam baris gilir

1. Model pengeluar-pengguna

Model pengeluar-pengguna menggunakan bekas untuk menyelesaikan masalah gandingan yang kuat antara pengeluar dan pengguna

Pengeluar dan pengguna tidak berkomunikasi secara langsung antara satu sama lain, tetapi Komunikasi dijalankan melalui baris gilir menyekat, jadi selepas pengeluar menghasilkan data, ia menunggu pengguna memprosesnya dan membuangnya terus ke baris gilir menyekat Pengguna tidak meminta data daripada pengeluar, tetapi terus mengambilnya daripada baris gilir penyekat

baris gilir menyekat Ia bersamaan dengan penimbal, mengimbangi keupayaan pemprosesan pengeluar dan pengguna

Bagi gilir menyekat juga boleh memisahkan pengeluar dan pengguna

Pelaksanaan perniagaan bakeri di atas adalah penggunaan pengeluar Satu contoh model pengendali

2. Baris gilir menyekat dalam perpustakaan standard

Baris gilir menyekat dibina ke dalam pustaka standard Java Jika kita perlu menggunakan baris gilir menyekat dalam beberapa program, gunakan standard perpustakaan terus. Dapatkannya

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的静态方法

Atas ialah kandungan terperinci Cara menggunakan tunggu dan maklumkan untuk melaksanakan komunikasi antara utas di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!