Beispielcode-Sharing von CountDownLatch für die Multithread-Synchronisierung in Java

Dieser Artikel stellt hauptsächlich die detaillierte Erklärung und den Beispielcode von CountDownLatch in Java für die Multi-Thread-Synchronisierung vor. Freunde in Not können sich auf

Detaillierte Erklärung der Multi-Thread-Synchronisierung durch CountDownLatch in Java

Einführung in CountDownLatch

In den vorherigen Java-Studiennotizen werden mehrere Methoden zur Multithread-Synchronisierung in Java zusammengefasst:

1. Schlüsselwort

synchronized für die Synchronisierung. 2. Die Sperre
der Schnittstelle und ihre Implementierungsklassen ReentrantLock und ReadWriteLock sorgen für eine Synchronisierung. 3. Semaphor erreicht Synchronisation.

Unter diesen lösen das synchronisierte Schlüsselwort und die Lock-Sperre das Problem des gleichzeitigen Zugriffs mehrerer Threads auf dieselbe Ressource. Semaphore löst das Problem des gemeinsamen Zugriffs auf mehrere Kopien von Ressourcen.

Heute lernen wir etwas über eine weitere Hilfsklasse für die Multithread-Synchronisierung in Java: CountDownLatch. In der offiziellen Dokumentation wird CountDownLatch wie folgt erklärt: Es ermöglicht einem oder mehreren Threads, zu warten, bis eine Reihe von Operationen, die in anderen Threads ausgeführt werden, abgeschlossen ist. Mit anderen Worten: CountDownLatch steuert einen oder mehrere Threads und lässt sie warten, bis mehrere Threads eine bestimmte Aufgabe abgeschlossen haben, bevor sie beginnen. CountDownLatch wird hauptsächlich zum Synchronisieren der Ausführung mehrerer Aufgaben verwendet. Es unterscheidet sich von anderen synchronisierten Schlüsselwörtern, Sperren und Semaphoren, die zum Synchronisieren gemeinsam genutzter Ressourcen verwendet werden.

Einführung in das Implementierungsprinzip von CountDownLatch:

CountDownLatch verwaltet intern einen Zähler. Der Wert des Zählers ist die Anzahl der auszuführenden Aufgaben abgeschlossen N, und Sie müssen auf dieses N warten. Ein Thread, der eine Aufgabe abgeschlossen hat, ruft die Methode „await()“ von

CountDownLatch auf, um sich in einen ruhenden Wartezustand zu versetzen.

Wenn ein Aufgabenthread eine Aufgabe abschließt, ruft er die countDown()-Methode von CountDownLatch auf, um anzuzeigen, dass seine Aufgabe abgeschlossen wurde. Zu diesem Zeitpunkt wird der Zählerwert von CountDownLatch um 1 reduziert Alle Aufgaben sind abgeschlossen, der Zählerwert ist 0. Wenn der Zählerwert 0 ist, weckt CountDownLatch alle Threads auf, die aufgrund der Methode „await()“ in den Ruhezustand gegangen sind.

Verwendung von CountDownLatch:

Es gibt drei Hauptpunkte für die Verwendung von CountDownLatch:

Erklärung von CountDownLatch Bei der Initialisierung müssen Sie die Anzahl der Aufgaben angeben, die während der Initialisierung auf den Abschluss warten.

2. Wenn eine bestimmte Aufgabe abgeschlossen ist, rufen Sie die countDown()-Methode von CountDownLatch auf, um zu melden, dass ihre Aufgabe abgeschlossen wurde.

3 Sie müssen warten, bis die Aufgabe abgeschlossen ist. Nach dem Aufruf wird der Thread in den Ruhezustand versetzt, nachdem alle Aufgaben abgeschlossen sind Die Methodewait() wird aktiviert.

Hier habe ich einige Verbesserungen basierend auf dem CountDownLatch-Verwendungsbeispiel im Java 7 Concurrent Programming Practical Manual vorgenommen, um die Verwendungsdetails von CountDownLatch zu demonstrieren:

Simulieren Sie ein Meeting mit 10 Teilnehmer und ein Moderator müssen warten, bis sich andere Teilnehmer angemeldet haben, bevor sie mit dem Meeting beginnen und sprechen können. Erstellen Sie dazu zunächst eine zu verwaltende Klasse „VideoConference“, die den Teilnehmern zum Einchecken eine „arive()“-Methode zur Verfügung stellt. Der Eigentümer des Konferenzmanagements ist der Gastgeber, der darauf wartet, dass sich jeder Teilnehmer anmeldet:

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(); 
    } 
  } 
}

Teilnehmerklasse erstellen. Teilnehmer:

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(); 
    } 
  } 
}

Hauptteil der Teilnehmerklasse

Funktion erstellt zunächst ein Meeting, an dem 10 Teilnehmer teilnehmen müssen. Anschließend werden 10 Teilnehmer erstellt und nacheinander angemeldet. Nachdem sich alle 10 Teilnehmer angemeldet haben, werden alle Teilnehmer und der Moderator „aufgeweckt“ und sprechen.

Zusammenfassung:

Die CountDownLatch-Klasse löst das Problem des Synchronisationswartens und der Aufgabenkoordination zwischen mehreren Threads. Sie kann beim Starten eines Programms verwendet werden .Vor der Hauptfunktion müssen im Voraus mehrere Unteraufgaben wie Konfigurationsumgebungsprüfung, Netzwerkprüfung usw. abgeschlossen werden. In Java können Sie nicht nur CountDownLatch verwenden, um synchrones Warten zwischen mehreren Threads zu erreichen, sondern auch die Barrieretechnologie CyclicBarrier verwenden, um synchrones Warten und Aufgabenkoordination zwischen mehreren Threads zu erreichen.

Das obige ist der detaillierte Inhalt vonBeispielcode-Sharing von CountDownLatch für die Multithread-Synchronisierung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!