Comment gérer les problèmes de communication inter-thread dans le développement Java

En tant que langage de programmation particulièrement adapté à la création d'applications multithread, Java peut exploiter pleinement les avantages des processeurs multicœurs pour améliorer la simultanéité et l'efficacité des programmes. Cependant, lors du développement multithread, la question de la communication entre les threads devient un défi majeur. Cet article présentera plusieurs méthodes courantes pour résoudre les problèmes de communication inter-thread.

1. Variables partagées

Les variables partagées sont l'un des moyens les plus simples et les plus courants de communiquer entre les threads. Plusieurs threads peuvent transmettre des informations en accédant et en modifiant les variables partagées. Cependant, étant donné que les threads s'exécutent en parallèle, des conditions de concurrence critique peuvent survenir. Pour éviter les conditions de concurrence, nous devons utiliser un mutex pour protéger l'accès aux variables partagées. Les verrous mutex peuvent être implémentés en Java à l'aide du mot clé synchronisé ou de l'interface Lock.

Ce qui suit est un exemple de code qui utilise des variables partagées pour la communication des threads :

public class SharedVariableExample {
    private int sharedVar = 0;

    public synchronized void increment() {
        sharedVar++;
    }

    public synchronized int getSharedVar() {
        return sharedVar;
    }
}

public class MyThread extends Thread {
    private SharedVariableExample example;

    public MyThread(SharedVariableExample example) {
        this.example = example;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            example.increment();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SharedVariableExample example = new SharedVariableExample();

        MyThread thread1 = new MyThread(example);
        MyThread thread2 = new MyThread(example);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("SharedVar: " + example.getSharedVar());
    }
}

Dans l'exemple ci-dessus, deux threads effectuent respectivement 10 opérations d'incrémentation sur les variables partagées et s'impriment après avoir attendu que tous les threads terminent leur exécution via la jointure ( ) méthode La valeur de la variable partagée.

2. Mécanisme d'attente/notification

Lors de l'utilisation de variables partagées pour la communication inter-thread, si un thread doit attendre le résultat d'un autre thread, nous pouvons utiliser le mécanisme d'attente/notification. Lorsqu'un thread doit attendre, il peut appeler la méthode wait() de l'objet pour mettre le thread dans un état d'attente. Lorsqu'une certaine condition est remplie, d'autres threads appellent la méthode notify() de l'objet pour réveiller le thread en attente.

Ce qui suit est un exemple de code qui utilise le mécanisme d'attente/notification pour la communication des threads :

public class WaitNotifyExample {
    private boolean flag = false;

    public synchronized void waitForSignal() {
        while (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag = false;
        System.out.println("Received signal");
    }

    public synchronized void sendSignal() {
        flag = true;
        notify();
    }
}

public class WaitThread extends Thread {
    private WaitNotifyExample example;

    public WaitThread(WaitNotifyExample example) {
        this.example = example;
    }

    public void run() {
        example.waitForSignal();
    }
}

public class NotifyThread extends Thread {
    private WaitNotifyExample example;

    public NotifyThread(WaitNotifyExample example) {
        this.example = example;
    }

    public void run() {
        example.sendSignal();
    }
}

public class Main {
    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        WaitThread waitThread = new WaitThread(example);
        NotifyThread notifyThread = new NotifyThread(example);

        waitThread.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        notifyThread.start();

        try {
            waitThread.join();
            notifyThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Dans l'exemple ci-dessus, le thread WaitThread attend que le signal soit reçu, le thread NotifyThread envoie le signal et réveille l'attente. thread après avoir attendu un certain temps via le thread de la méthode sleep().

3. Blocking Queue

Blocking Queue est un moyen efficace d'établir la communication entre les threads. Il fournit les méthodes put() et take(), qui peuvent automatiquement bloquer et attendre lorsque la file d'attente est pleine ou vide jusqu'à ce que les conditions soient remplies.

Voici un exemple de code utilisant une file d'attente de blocage pour la communication par thread :

import java.util.concurrent.ArrayBlockingQueue;

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!