Analyse des méthodes de communication multithread Java

En Java, les méthodes de communication multithread incluent les variables partagées, l'attente/notification, les sémaphores et les canaux. Les variables partagées facilitent l'échange de données mais sont sujettes à des problèmes de concurrence ; wait/notify utilise un mécanisme de synchronisation pour attendre et se réveiller entre les threads ; les threads limitent le nombre de threads accédant aux ressources en même temps ;

Analyse de la communication multithread Java

Introduction

Le multithreading est un concept important dans la programmation concurrente, qui permet d'exécuter plusieurs tâches simultanément. Afin de mettre en œuvre l'échange de données dans un environnement multithread, nous devons comprendre diverses méthodes de communication. Cet article examinera en profondeur les méthodes de communication multithread courantes en Java, notamment les variables partagées, l'attente/notification, les sémaphores et les canaux.

Variables partagées

Les variables partagées sont des variables globales accessibles par plusieurs threads. Lorsqu'un thread modifie une variable partagée, les autres threads peuvent voir les modifications. Cependant, les variables partagées sont sujettes à des problèmes de concurrence, tels que des conditions de concurrence critique et un comportement imprévisible.

Cas pratique :

public class SharedVariableExample {
    private static int sharedCounter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                sharedCounter++;
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                sharedCounter--;
            }
        });

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

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

        System.out.println("最终共享计数器：" + sharedCounter);
    }
}

wait/notify

wait/notify est le mécanisme de synchronisation intégré à Java. La méthode wait() mettra le thread actuel dans un état d'attente jusqu'à ce que d'autres threads appellent la méthode notify() ou notifyAll() pour le réveiller.

Cas pratique :

public class WaitNotifyExample {
    private static Object lock = new Object();

    private static boolean dataAvailable = false;

    public static void main(String[] args) throws InterruptedException {
        Thread producer = new Thread(() -> {
            synchronized (lock) {
                while (!dataAvailable) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println("处理数据...");
            }
        });

        Thread consumer = new Thread(() -> {
            synchronized (lock) {
                dataAvailable = true;
                lock.notify();
            }
        });

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();
    }
}

Semaphore

Un sémaphore est un mécanisme de synchronisation qui permet à un nombre précis de threads d'accéder à une ressource en même temps. Lorsqu'un thread acquiert un sémaphore, le compteur du sémaphore est décrémenté ; lorsqu'il libère le sémaphore, le compteur est incrémenté.

Cas pratique :

public class SemaphoreExample {
    private static Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("线程 1 进入临界区");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("线程 2 进入临界区");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });

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

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

Pipeline

Pipeline est une structure de données spéciale utilisée pour la communication entre les threads. C'est comme un tampon, un thread peut écrire des données et un autre thread peut lire des données.

Cas pratique :

public class PipeExample {
    private static PipedOutputStream pos = new PipedOutputStream();
    private static PipedInputStream pis = new PipedInputStream(pos);

    public static void main(String[] args) throws IOException {
        Thread writer = new Thread(() -> {
            try {
                pos.write("你好，世界！".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                pos.close();
            }
        });

        Thread reader = new Thread(() -> {
            try {
                byte[] data = new byte[1024];
                int length = pis.read(data);
                System.out.println(new String(data, 0, length));
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                pis.close();
            }
        });

        writer.start();
        reader.start();

        writer.join();
        reader.join();
    }
}

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!