Comment utiliser wait and notify pour implémenter la communication entre les threads en Java-javaDidacticiel-php.cn

1. Pourquoi la communication entre les threads est nécessaire

Les threads sont exécutés simultanément, ce qui semble être une exécution aléatoire des threads. Cependant, dans les applications réelles, nous avons des exigences concernant l'ordre d'exécution des threads, ce qui nécessite l'utilisation de threads. communication.

Pourquoi la communication des threads n'utilise-t-elle pas la priorité pour résoudre l'ordre de passage des threads ?

La priorité globale est déterminée par les informations de priorité dans la carte PCB du thread et le temps d'attente du thread, donc dans le développement général, la priorité n'est pas utilisée pour indiquer l'ordre d'exécution des threads

Regardez la scène suivante : boulangerie Exemple pour décrire le modèle producteur-consommateur

Il y a une boulangerie avec des boulangers et des clients, correspondant à nos producteurs et consommateurs, et la boulangerie a un inventaire pour stocker le pain Quand l'inventaire est plein, elle ne produira plus En même temps, des consommateurs. achètent également du pain. Lorsque le stock de pain est épuisé, les consommateurs doivent attendre que du nouveau pain soit produit avant de pouvoir continuer à acheter. Analyse : Quand arrêter la production et quand arrêter la consommation, la communication par fil doit être appliquée avec précision. déterminer Transmettre les informations de production et de consommation

2. Méthodes d'attente et de notification

wait() : Laissez l'objet se verrouiller détenu par la version de thread actuelle et attendez

wait(long timeout) : Le paramètre correspondant est le temps pendant lequel le thread attend

notify( ) : réveille le thread qui utilise le même objet pour appeler wait pour entrer dans le thread en attente et rivalise à nouveau pour le verrouillage de l'objet

notifyAll() : s'il y a plusieurs threads en attente, notifyAll réveille tous, notifie le réveil en créer un au hasard

Remarque :

Ces plusieurs méthodes sont toutes des méthodes de la classe Object

Doivent être utilisées dans les blocs de code de synchronisation synchronisés/méthodes de synchronisation

Quel objet est verrouillé, c'est l'objet qui attend et est averti

Après l'appel notifier, il ne se réveille pas immédiatement, mais attend synchronisé Après la fin, réveillez-vous

1. Méthode wait()

Après avoir appelé la méthode wait :

Faites attendre le thread exécutant le code actuel (le thread est placé dans la file d'attente)

Libérer le verrou actuel

Remplir certaines conditions Au réveil, essayez à nouveau d'acquérir le verrou

Conditions d'attente pour terminer :

D'autres threads appellent la méthode notify de l'objet

wait wait time expire (paramètre timeout pour spécifier le temps d'attente)

D'autres threads appellent la méthode interrompue, ce qui provoque l'attente pour lancer InterruptedException

2 méthode notify()

Lorsque vous utilisez la méthode wait sans paramètres, vous devez utiliser. la méthode notify pour réveiller le thread en attente.

Cette méthode consiste à réveiller les threads en attente du verrouillage de l'objet, leur permettant de réacquérir le verrouillage de l'objet

S'il y a plusieurs threads en attente, le thread. le planificateur sélectionnera au hasard un thread en état d'attente (il n'y a pas de premier arrivé, premier servi)

Après la méthode notify(), le thread actuel ne sera pas libéré immédiatement. Le verrouillage de l'objet ne sera pas libéré. libéré jusqu'à ce que le thread exécutant la méthode notify() ait fini d'exécuter le programme, c'est-à-dire après avoir quitté le bloc de code synchronisé

3 Méthode notifyAll()

Cette méthode et la méthode notify() La fonction est la même, sauf que lorsque au réveil, tous les threads en attente sont réveillés

La méthode notify() réveille juste un thread au hasard

3 Utilisez wait et notify pour mettre en œuvre une activité de boulangerie

Instructions préalables :

Il y a 2 Baker, le boulanger peut faire. deux pains à la fois

L'entrepôt peut stocker 100 pains

Il y a 10 consommateurs, chaque consommateur achète un pain à la fois

Remarque :

La consommation et la production sont concurrentes en même temps Elle est réalisée en parallèle, pas une production et une consommation

Code d'implémentation :

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

Copier après la connexion

Résultats d'impression partiels :

Comment utiliser wait and notify pour implémenter la communication entre les threads en Java 4. File d'attente de blocage

La file d'attente de blocage est une file d'attente spéciale qui suit également le "premier entré, premier sorti " principe En principe, il s'agit d'une structure de file d'attente thread-safe

Caractéristiques : Modèle typique producteur-consommateur, généralement utilisé pour découpler les tâches et éliminer les pics

Lorsque la file d'attente est pleine, la file d'attente sera bloquée et attendue (production) jusqu'à il y a D'autres threads prennent des éléments de la file d'attente

Lorsque la file d'attente est vide, la file d'attente est bloquée et attendue (consommée) jusqu'à ce que d'autres threads insèrent des éléments dans la file d'attente

1 Modèle producteur-consommateur

Le modèle producteur-consommateur est transmis. Un conteneur pour résoudre le problème de couplage fort entre producteurs et consommateurs

Les producteurs et les consommateurs ne communiquent pas directement entre eux, mais communiquent via des files d'attente bloquantes, donc après que le producteur a produit les données, il attend que le consommateur les traite et les lance directement dans la file d'attente de blocage, le consommateur ne demande pas de données au producteur, mais les extrait directement de la file d'attente de blocage. La file d'attente de blocage est équivalente à un tampon, équilibrant les capacités de traitement du producteur et de la file d'attente de blocage. peut également permettre aux producteurs et au découplage entre les consommateurs

La mise en œuvre de l'activité de boulangerie mentionnée ci-dessus est un exemple du modèle producteur-consommateur

2 File d'attente de blocage dans la bibliothèque standard

La file d'attente de blocage est intégrée à Java. bibliothèque standard. Si nous devons utiliser une file d'attente de blocage dans le programme, utilisez simplement celle de la bibliothèque standard

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

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

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

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

Copier après la connexion

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

Copier après la connexion