Exemple de partage de code de CountDownLatch pour la synchronisation multithread en Java

Cet article présente principalement l'explication détaillée et l'exemple de code de CountDownLatch en Java pour la synchronisation multi-thread. Les amis dans le besoin peuvent se référer à

Explication détaillée de la synchronisation multi-thread par CountDownLatch en Java<.>

Introduction à CountDownLatch

Dans les notes d'étude Java précédentes, plusieurs méthodes de synchronisation multithread en Java sont résumées :

1. Mot-clé

synchronisé pour la synchronisation. 2. Lock lock
interface et ses classes d'implémentation ReentrantLock et ReadWriteLock les verrous réalisent la synchronisation. 3. Le sémaphore réalise la synchronisation.

Parmi eux, le mot-clé synchronisé et le verrouillage Lock résolvent le problème de l'accès simultané à la même ressource par plusieurs threads. Semaphore résout le problème de l'accès partagé à plusieurs copies de ressources.

Aujourd'hui, découvrons une autre classe auxiliaire de synchronisation multi-thread en Java : CountDownLatch. La documentation officielle explique CountDownLatch comme suit : Il permet à un ou plusieurs threads d'attendre qu'un ensemble d'opérations effectuées dans d'autres threads soit terminé. En d'autres termes, CountDownLatch contrôle un ou plusieurs threads et leur permet d'attendre que plusieurs threads terminent une certaine tâche avant de commencer. CountDownLatch est principalement utilisé pour synchroniser l'exécution de plusieurs tâches. Il est différent des autres mots-clés, verrous et sémaphores synchronisés, qui sont utilisés pour synchroniser les ressources partagées.

Introduction au principe de mise en œuvre de CountDownLatch :

CountDownLatch maintient un compteur en interne La valeur du compteur est le nombre de tâches à effectuer. terminé N, et vous devez attendre ce N. Un thread qui a terminé une tâche appelle la méthode wait() de

CountDownLatch pour se mettre dans un état d'attente dormant.

Lorsqu'un thread de tâche termine une tâche, il appelle la méthode countDown() de CountDownLatch pour indiquer que sa tâche est terminée. À ce moment, la valeur du compteur de CountDownLatch est réduite de 1. Lorsque. toutes les tâches sont terminées, la valeur du compteur est 0. Lorsque la valeur du compteur est 0, CountDownLatch réveillera tous les threads qui se sont endormis à cause de la méthode wait().

Utilisation de CountDownLatch :

Il y a trois points principaux pour utiliser CountDownLatch :

1. CountDownLatch Et lors de l'initialisation, vous devez spécifier le nombre de tâches en attente d'être terminées lors de l'initialisation.

2. Lorsqu'une certaine tâche est terminée, appelez la méthode countDown() de CountDownLatch pour signaler à CountDownLatch que sa tâche est terminée

3. Vous devez attendre que la tâche soit terminée. Appelez la méthode wait() de CountDownLatch. Après l'appel, le thread se met en veille. Lorsque la valeur du compteur de CountDownLatch atteint 0 une fois toutes les tâches terminées, le thread se met en veille à cause de la tâche. La méthode wait() sera réveillée.

Ici, j'ai apporté quelques améliorations basées sur l'exemple d'utilisation de CountDownLatch dans le manuel pratique de programmation simultanée Java 7 pour démontrer les détails d'utilisation de CountDownLatch :

Simulez une réunion avec 10 participants et un modérateur. Chaque participant et modérateur doit attendre que les autres participants se connectent avant de pouvoir démarrer la réunion et prendre la parole. Pour ce faire, créez d'abord une classe VidéoConférence qui sera gérée, qui fournit une méthode arrive() que les participants pourront appeler pour s'enregistrer. Le propriétaire de la gestion de la conférence est l'hôte, qui attend que chaque participant se connecte :

public class VideoConference implements Runnable{ 
  private final CountDownLatch countDownLatch; 
  private int number; 
  public VideoConference(int number) { 
    this.number = number; 
    this.countDownLatch = new CountDownLatch(number);//使用Number初始化其内部的计数器，当初始化完成后，不能再次初始化 
  } 
  public void arrive(String name){ 
    //每个需要同步的任务，在任务完成时，需要调用该方法 
    countDownLatch.countDown();//countDownLatch内部的计数器减1 
    System.out.print("arrive:"+name+"\n"); 
    try{ 
      countDownLatch.await();//await方法是线程进入休眠，当countDownLatch计数器为0时，将被唤醒 
      //线程被唤醒，在这里可以执行一系列任务 
      System.out.print("name:"+name + " say:let's start..." +"\n"); 
    }catch (InterruptedException e){ 
      e.printStackTrace(); 
    } 
  } 
  public void run(){ 
    System.out.print("has arrive:"+(number-countDownLatch.getCount())+"\n"); 
    try{ 
      countDownLatch.await();//await方法是线程进入休眠，当countDownLatch计数器为0时，将被唤醒 
      //线程被唤醒，在这里可以执行一系列任务 
      System.out.print("all arrived:"+(number-countDownLatch.getCount())+"\n"); 
    }catch (InterruptedException e){ 
      e.printStackTrace(); 
    } 
  } 
}

Créer une classe de participant Participant :

public class Participant implements Runnable{ 
  private VideoConference videoConference; 
  private String name; 
 
  public Participant(String name, VideoConference videoConference) { 
    this.name = name; 
    this.videoConference = videoConference; 
  } 
  public void run(){ 
    try { 
      //do something 
      Thread.sleep(50); 
      // 
      videoConference.arrive(name); 
    }catch (InterruptedException e){ 
      e.printStackTrace(); 
    } 
  } 
 
  public static void main(String[] args){ 
    VideoConference videoConference = new VideoConference(10); 
    Thread videoThread = new Thread(videoConference); 
    videoThread.start(); 
    for(int i=0; i<10; i++){ 
      Thread thread = new Thread(new Participant("participant:"+i,videoConference)); 
      thread.start(); 
    } 
  } 
}

main dans la classe Participant

Fonction crée d'abord une réunion qui nécessite la participation de 10 participants. Après cela, 10 participants sont créés et se connectent un par un. Une fois que les 10 participants se sont connectés, chaque participant et le modérateur seront « réveillés » et prendront la parole.

Résumé :

La classe CountDownLatch résout le problème de l'attente de synchronisation et de la coordination des tâches entre plusieurs threads. Elle peut être utilisée lors du démarrage d'un programme. . Avant la fonction principale, plusieurs sous-tâches telles que la vérification de l'environnement de configuration, la vérification du réseau, etc. doivent être effectuées à l'avance et dans des scénarios similaires. En Java, en plus d'utiliser CountDownLatch pour obtenir une attente synchrone entre plusieurs threads, vous pouvez également utiliser la technologie de barrière CyclicBarrier pour obtenir une attente synchrone et une coordination des tâches entre plusieurs threads.

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!