Une plongée approfondie dans la programmation simultanée Java : de l'attente et de la notification à java.util.concurrent

De wait and notify à java.util.concurrent : explorez les méthodes avancées de programmation simultanée Java

En programmation Java, la mise en œuvre de la concurrence est une tâche courante mais également difficile. Afin de résoudre efficacement les problèmes de concurrence, Java fournit des outils et des classes de base, tels que le mot-clé synchronisé, les méthodes wait et notify et la classe Thread. Cependant, à mesure que les applications deviennent de plus en plus complexes, ces outils de base se révèlent souvent insuffisants. Afin de mieux gérer la concurrence, Java a également introduit le package java.util.concurrent, qui fournit des méthodes et des outils de programmation simultanée plus avancés. Cet article explorera certaines méthodes avancées, depuis wait and notify jusqu'à java.util.concurrent, tout en fournissant des exemples de code spécifiques.

wait et notify sont des méthodes de la classe Object et sont utilisées pour implémenter la communication entre les threads. La méthode wait met le thread dans un état d'attente jusqu'à ce que d'autres threads appellent la méthode notify pour le réveiller. Ce mécanisme est largement utilisé pour réaliser la synchronisation entre les threads. Voici un exemple simple :

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 is waiting");
                    lock.wait();
                    System.out.println("Thread 1 is resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 is notifying");
                lock.notify();
            }
        });

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

Le code ci-dessus crée deux threads, dans lesquels thread1 appelle la méthode wait pour entrer dans l'état d'attente, et thread2 appelle la méthode notify pour réveiller le thread1. De cette façon, thread1 poursuivra son exécution.

Cependant, ce mécanisme d'attente et de notification de base n'est souvent pas suffisamment flexible et efficace dans les applications pratiques. Il ne peut pas résoudre les problèmes de concurrence complexes tels que la gestion des pools de threads, les verrous réentrants, les verrous en lecture-écriture, etc. Pour mieux gérer ces problèmes, Java fournit le package java.util.concurrent.

Ce package fournit des méthodes et des outils de programmation simultanée plus avancés. Voici quelques classes et interfaces couramment utilisées :

1. Interface Executor : définit des outils de haut niveau pour gérer l'exécution des threads. Les threads peuvent être créés et gérés à l'aide des classes d'implémentation fournies par le pool de threads.

Executor executor = Executors.newFixedThreadPool(5);
executor.execute(() -> {
    // 执行任务
});

2. Interface de verrouillage : fournit un mécanisme de verrouillage plus flexible et réentrant que celui synchronisé. ReentrantLock est une implémentation de l'interface Lock.

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 执行线程安全的操作
} finally {
    lock.unlock();
}

3. Interface de condition : utilisée conjointement avec l'interface Lock pour obtenir une communication inter-thread plus précise. Les fonctions d'attente et de notification peuvent être implémentées via les méthodes wait, signal et signalAll.

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    while (!conditionIsMet()) {
        condition.await();
    }
    // 执行逻辑
} finally {
    lock.unlock();
}

4. Classe CountDownLatch : utilisée pour contrôler l'attente d'exécution du thread. Vous pouvez définir un compteur Lorsque le compteur atteint 0, le thread en attente poursuivra son exécution.

CountDownLatch latch = new CountDownLatch(3);

Thread thread1 = new Thread(() -> {
    // 执行任务
    latch.countDown();
});

Thread thread2 = new Thread(() -> {
    // 执行任务
    latch.countDown();
});

Thread thread3 = new Thread(() -> {
    // 执行任务
    latch.countDown();
});

latch.await();
// 等待三个线程执行完毕后继续执行

5. Classe Sémaphore : utilisée pour contrôler le nombre de threads accédant à une ressource en même temps. Vous pouvez limiter uniformément le nombre de threads s’exécutant simultanément.

Semaphore semaphore = new Semaphore(3);

Thread thread1 = new Thread(() -> {
    try {
        semaphore.acquire();
        // 执行任务
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();
    }
});

Thread thread2 = new Thread(() -> {
    try {
        semaphore.acquire();
        // 执行任务
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();
    }
});

// 最多允许3个线程同时执行

En utilisant ces méthodes et outils avancés, nous pouvons mieux gérer les problèmes de concurrence et améliorer les performances et la fiabilité de nos applications. Cependant, il est important de noter qu’une attention particulière à la sécurité des threads et au contrôle de la concurrence est nécessaire lors de l’utilisation de ces fonctionnalités.

Pour résumer, Java fournit des méthodes avancées depuis les méthodes de base d'attente et de notification jusqu'au package java.util.concurrent plus avancé pour gérer la programmation simultanée. Nous pouvons choisir des méthodes et des outils appropriés en fonction des besoins réels et de la complexité du problème. En exploitant correctement les méthodes de programmation simultanée, nous pouvons mieux gérer l'exécution des threads, éviter les situations de concurrence critique et les blocages, et améliorer les performances et la qualité des applications.

J'espère que les exemples de code et les méthodes fournis dans cet article vous seront utiles dans votre apprentissage et votre pratique de la programmation simultanée en Java.

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!