Comment implémenter la communication inter-thread dans la concurrence des fonctions Java et le multi-threading ?

La communication par thread Java est cruciale en matière de concurrence et de multi-threading. Il existe quatre méthodes courantes : données partagées, mécanisme de notification d'attente, file d'attente simultanée et échange. Le partage de données implique l'utilisation de variables ou d'objets partagés, les mécanismes d'attente-notification permettent aux threads d'attendre des conditions spécifiques, les files d'attente simultanées fournissent des structures de données thread-safe et les échangeurs permettent aux threads appariés d'échanger des données lorsqu'ils sont prêts.

Communication par thread Java : communication entre les threads en simultanéité et multi-threading

Dans la programmation simultanée en Java, la communication par thread est la clé pour parvenir à la collaboration et au partage des ressources. Il existe différents mécanismes permettant de transmettre des informations entre plusieurs threads et de coordonner leur comportement. Ce didacticiel explorera les méthodes courantes de communication par thread en Java et les illustrera avec des exemples pratiques.

1. Partage de données

Le moyen le plus simple de communication entre threads est de partager des variables ou des objets publics entre les threads. Pour y parvenir, vous pouvez utiliser le mot-clé volatile pour garantir la visibilité et l'ordre des variables. volatile 关键字来确保变量的可见性和有序性。

// 共享变量
public class SharedData {
    public volatile int value;
}

// 线程 1
public void increment() {
    sharedData.value++;
}

// 线程 2
public void decrement() {
    sharedData.value--;
}

2. 等待-通知机制

使用 Object 的 wait() 和 notify()

// 生产者-消费者模型
public class WaitNotify {

    private final Queue<Integer> queue;
    private final Object lock = new Object();

    // 生产者线程
    public void produce() {
        synchronized (lock) {
            while (queue.size() >= maxSize) {
                lock.wait();
            }
            queue.add(value);
            lock.notifyAll();
        }
    }

    // 消费者线程
    public void consume() {
        synchronized (lock) {
            while (queue.isEmpty()) {
                lock.wait();
            }
            value = queue.remove();
            lock.notifyAll();
        }
    }
}

2. Mécanisme de notification en attente

En utilisant les méthodes wait() et notify() de Object, les threads peuvent attendre pour les autres Un thread notifie qu'une condition spécifique a été remplie. Cela permet aux threads de dormir avant qu'un événement ne se produise, évitant ainsi une utilisation inutile du processeur.

// 使用 ConcurrentLinkedQueue
public class ConcurrencyQueue {

    private final ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

    // 生产者线程
    public void produce() {
        queue.add(value);
    }

    // 消费者线程
    public void consume() {
        Integer value = queue.poll();
    }
}

3. Concurrent Queue

Java fournit des classes de files d'attente simultanées telles que ConcurrentHashMap et ConcurrentLinkedQueue, qui peuvent être partagées en toute sécurité entre plusieurs threads. Ils utilisent un mécanisme de verrouillage interne pour garantir un fonctionnement correct.

// 使用 Exchanger
public class ExchangerExample {

    private final Exchanger<Integer> exchanger = new Exchanger<>();

    // 线程 1
    public void exchange() {
        try {
            Integer value = exchanger.exchange(value); // 交换值
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 线程 2
    public void exchange() {
        try {
            Integer value = exchanger.exchange(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4. Exchanger

🎜🎜Exchanger permet aux threads de communiquer après l'appairage. L'échangeur libère tous les threads lorsqu'ils sont prêts à échanger des données. 🎜rrreee🎜Grâce à ces mécanismes, une communication efficace entre les threads peut être obtenue pour créer des applications complexes à haute concurrence. Le choix de la méthode de communication la plus appropriée dépend des besoins spécifiques de l'application et des considérations de performances. 🎜

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!