Méthode d'implémentation de la synchronisation des threads et de l'exclusion mutuelle en langage Java

Le langage Java est un langage qui a introduit le multithreading à ses débuts. L'utilisation de threads fait briller le langage Java dans le traitement simultané des programmes. Cependant, les problèmes de synchronisation et d’exclusion mutuelle entre les threads ont toujours été la clé du processus de programmation. Dans le langage Java, il existe de nombreuses façons d'implémenter la synchronisation des threads et l'exclusion mutuelle. Cet article en présentera plusieurs.

1. Utilisez le mot-clé synchronisé pour obtenir la synchronisation et l'exclusion mutuelle

Synchronisé est le moyen le plus basique d'obtenir la synchronisation et l'exclusion mutuelle dans le langage Java. En Java, chaque objet possède un moniteur. Lorsqu'un thread entre dans le bloc de code du moniteur, il obtient le verrou de l'objet et les autres threads qui doivent exécuter le bloc de code de verrouillage ne peuvent qu'attendre. Lorsqu'un thread termine l'exécution, le verrou de l'objet est libéré et les autres threads en attente de l'objet peuvent entrer dans le bloc de code et répéter le processus ci-dessus.

L'implémentation utilisant synchronisé est relativement simple, il suffit d'ajouter le mot-clé synchronisé avant la méthode ou le bloc de code qui doit être synchronisé. Par exemple :

public synchronized void method1(){
  //...
}

Ou en utilisant un bloc de code :

public void method1(){
  synchronized(this) {
    //...
  }
}

Une autre forme de synchronisation est un verrouillage de classe. Lors de l'utilisation de verrous de classe, le moniteur est un objet Class de la même classe. Par exemple :

public class MyClass {
  public static synchronized void method1(){
    //...
  }
}

Dans le code ci-dessus, toutes les instances de MyClass partagent le même objet Class de la classe MyClass.

2. Utilisez ReentrantLock pour réaliser la synchronisation et l'exclusion mutuelle

Différent du mot-clé synchronisé, ReentrantLock est une classe plutôt qu'un mot-clé. ReentrantLock a des fonctions similaires à synchronisées, mais offre un contrôle plus puissant des mécanismes de synchronisation et d'exclusion mutuelle. En revanche, l'utilisation de ReentrantLock est plus flexible, par exemple, il peut réaliser une acquisition de verrou équitable, compter le nombre d'acquisitions de verrou par un thread, etc.

ReentrantLock est utilisé comme suit :

ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
  //...
} finally {
  lock.unlock();
}

ReentrantLock est réentrant, c'est-à-dire que le même thread peut obtenir le verrou plusieurs fois.

3. Utilisez CountDownLatch pour réaliser la synchronisation

CountDownLatch est une classe d'outils pour la synchronisation des threads, qui permet à un ou plusieurs threads d'attendre qu'un ou plusieurs threads terminent leur exécution. CountDownLatch fournit un compte à rebours. Le thread qui doit attendre doit appeler la méthode Countdown() pour décrémenter le compteur de 1. Lorsque le compteur est à 0, le thread en attente peut continuer à s'exécuter.

L'utilisation de CountDownLatch permet à un thread d'attendre qu'un autre thread démarre avant de continuer. Par exemple :

//初始化计数器为1
CountDownLatch latch = new CountDownLatch(1);

//线程1
new Thread(new Runnable() {
  public void run(){
    //其他操作
    latch.countDown();
  }
}).start();

//线程2等待线程1启动完毕
latch.await();

//线程2继续执行

4. Utilisez Semaphore pour réaliser la synchronisation et l'exclusion mutuelle

Semaphore est une autre classe d'outils de concurrence Java qui vous permet de contrôler le nombre de threads qui accèdent simultanément à des ressources spécifiques. Semaphore conserve un ensemble de licences Lorsqu'un thread demande une licence, il peut recevoir la licence et poursuivre l'exécution. Lorsque la licence est épuisée, vous devez attendre que d'autres threads renvoient la licence avant de continuer.

Utilisez Sémaphore pour limiter le nombre de threads accédant à une ressource en même temps, par exemple :

//初始化Semaphore，设定同时允许2个线程访问
Semaphore semaphore = new Semaphore(2);

//其他线程请求许可证
semaphore.acquire();

//许可证使用完毕后释放
semaphore.release();

Résumé :

Il existe plusieurs méthodes ci-dessus pour obtenir la synchronisation des threads et l'exclusion mutuelle dans le langage Java, parmi lesquelles synchronisé est le méthode d'implémentation la plus basique, ReentrantLock fournit un mécanisme de contrôle plus puissant, tandis que CountDownLatch et Semaphore peuvent bien contrôler la collaboration et la concurrence entre les threads. Dans la programmation réelle, une sélection raisonnable et une utilisation flexible de ces outils peuvent efficacement éviter les problèmes de synchronisation des threads et d'exclusion mutuelle dans les programmes 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!