Comment résoudre les problèmes de communication inter-thread en Java

Comment résoudre un problème de communication inter-thread en Java ?

Dans la programmation multithread Java, la communication inter-thread est un concept important. Dans les applications pratiques, différents threads peuvent devoir coopérer les uns avec les autres, partager des données ou interagir. Cependant, comme les threads s'exécutent simultanément, nous avons besoin de mécanismes appropriés pour garantir une communication correcte entre les threads. En Java, nous pouvons résoudre le problème de la communication inter-thread des manières suivantes.

1. Communiquez à l'aide de variables partagées

Les variables partagées sont le moyen le plus simple et le plus direct de communiquer. Plusieurs threads peuvent communiquer en lisant et en écrivant des variables partagées. En Java, les variables partagées doivent être modifiées à l'aide du mot-clé volatile pour garantir la visibilité. Dans le même temps, nous devons également utiliser le mot-clé synchronisé pour garantir l'atomicité et empêcher plusieurs threads de lire et d'écrire des variables partagées en même temps.

Ce qui suit est un exemple de code simple :

public class SharedVariableCommunication {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }

    public boolean getFlag() {
        return flag;
    }

    public static void main(String[] args) throws InterruptedException {
        SharedVariableCommunication communication = new SharedVariableCommunication();

        Thread thread1 = new Thread(() -> {
            // do something
            communication.setFlag(true);
        });

        Thread thread2 = new Thread(() -> {
            while (!communication.getFlag()) {
                // waiting
            }
            // continue execution
        });

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

        thread1.join();
        thread2.join();
    }
}

Dans le code ci-dessus, le thread thread1 définit l'indicateur sur true via la méthode setFlag, tandis que le thread thread2 vérifie en permanence la valeur de l'indicateur via la méthode getFlag et ne continue pas à exécuter jusqu'à ce que ce soit vrai.

2. Utilisez les méthodes d'attente et de notification pour communiquer

Java fournit les méthodes d'attente et de notification de la classe Object, qui peuvent être utilisées pour les opérations d'attente et de réveil entre les threads. Le thread suspend sa propre exécution via la méthode wait et libère le verrou de l'objet, tandis que d'autres threads réveillent le thread en attente via la méthode notify et poursuivent l'exécution.

Ce qui suit est un exemple de code utilisant les méthodes wait et notify :

public class WaitNotifyCommunication {
    private boolean flag = false;

    public synchronized void setFlag(boolean value) {
        flag = value;
        notify();
    }

    public synchronized void getFlag() throws InterruptedException {
        while (!flag) {
            wait();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        WaitNotifyCommunication communication = new WaitNotifyCommunication();

        Thread thread1 = new Thread(() -> {
            // do something
            communication.setFlag(true);
        });

        Thread thread2 = new Thread(() -> {
            try {
                communication.getFlag();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // continue execution
        });

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

        thread1.join();
        thread2.join();
    }
}

Dans le code ci-dessus, le thread thread1 définit l'indicateur sur true via la méthode setFlag et appelle la méthode notify pour réveiller le thread en attente thread2. Le thread thread2 attend via la méthode wait à l'intérieur de la méthode getFlag jusqu'à ce qu'il soit réveillé par thread1 et continue d'effectuer les opérations suivantes.

3. Utilisez Lock et Condition pour communiquer

En plus d'utiliser le mot-clé synchronisé, Java fournit également les interfaces Lock et Condition pour contrôler la synchronisation et la communication des threads de manière plus fine. L'interface Condition fournit des méthodes telles que wait, signal et signalAll, qui peuvent être utilisées pour attendre et réactiver des opérations entre les threads.

Ce qui suit est un exemple de code utilisant Lock et Condition :

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockConditionCommunication {
    private boolean flag = false;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void setFlag(boolean value) {
        lock.lock();
        try {
            flag = value;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    public void getFlag() throws InterruptedException {
        lock.lock();
        try {
            while (!flag) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockConditionCommunication communication = new LockConditionCommunication();

        Thread thread1 = new Thread(() -> {
            // do something
            communication.setFlag(true);
        });

        Thread thread2 = new Thread(() -> {
            try {
                communication.getFlag();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // continue execution
        });

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

        thread1.join();
        thread2.join();
    }
}

Dans l'exemple de code ci-dessus, ReentrantLock et Condition sont utilisés pour assurer la synchronisation et la communication des threads. Thread thread1 définit l'indicateur sur true via la méthode setFlag et appelle la méthode condition.signal pour réveiller le thread en attente thread2. Le thread thread2 attend la méthode condition.await à l'intérieur de la méthode getFlag jusqu'à ce qu'il soit réveillé par thread1 et continue d'effectuer les opérations suivantes.

Résumé : Il existe de nombreuses façons de résoudre le problème de la communication inter-thread en Java. Le choix de la méthode appropriée dépend des scénarios et des exigences spécifiques de l'application. Que vous utilisiez des variables partagées, des méthodes d'attente et de notification ou des interfaces Lock and Condition, vous devez veiller à gérer correctement les relations de synchronisation et d'exclusion mutuelle entre les threads pour éviter les problèmes de concurrence et les blocages. Nous espérons que les exemples de code ci-dessus pourront aider les lecteurs à mieux comprendre et appliquer les technologies associées de communication inter-thread.

(Remarque : le code ci-dessus n'est qu'un exemple et peut présenter des lacunes. Les lecteurs doivent apporter les modifications et améliorations appropriées en fonction des besoins spécifiques des applications réelles.)

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!