Example code sharing of CountDownLatch for multi-thread synchronization in Java

This article mainly introduces the detailed explanation and example code of CountDownLatch in Java for multi-thread synchronization. Friends in need can refer to the following

Detailed explanation of multi-thread synchronization by CountDownLatch in Java

Introduction to CountDownLatch

In the previous Java study notes, several methods for multi-thread synchronization in Java are summarized:

1, synchronized keywords for synchronization.
2. Lock lockInterfaceand its implementation classesReentrantLock, ReadWriteLock locks realize synchronization.
3. Semaphore achieves synchronization.

Among them, the synchronized keyword and Lock lock solve the problem of concurrent access to the same resource by multiple threads. Semaphore solves the problem of shared access to multiple copies of resources.

Today, let’s learn about another multi-thread synchronization auxiliary class in Java: CountDownLatch. The official documentation explains CountDownLatch as: It allows one or more threads to wait until a set of operations being performed in other threads is completed. In other words, CountDownLatch controls one or more threads and lets them wait for multiple threads to complete a certain task before starting. CountDownLatch is mainly used to synchronize the execution of multiple tasks. It is different from other synchronized keywords, locks, and semaphores, which are used to synchronize shared resources.

Introduction to the implementation principle of CountDownLatch:

CountDownLatch maintains a counter internally. The value of the counter is the number of tasks to be completed N. You need to wait for these N A thread that has completed a task calls the await() method of

CountDownLatch to put itself into a dormant waiting state.

When a task thread completes a task, it calls the countDown() method of CountDownLatch to indicate that its task has been completed. At this time, the counter value of CountDownLatch is reduced by 1. When all tasks are completed, The counter value is 0. When the counter value is 0, CountDownLatch will wake up all threads that went to sleep due to the await() method.

Usage of CountDownLatch:

There are three main points in the use of CountDownLatch:

1. Statement of CountDownLatch And initialization, you need to specify the number of tasks waiting to be completed during initialization.

2. When a certain task is completed, call the countDown() method of CountDownLatch to report to CountDownLatch that its task has been completed.

3. The thread that needs to wait for the task to be completed Call the await() method of CountDownLatch. After the call, the thread will go to sleep. When the counter value of CountDownLatch reaches 0 after all tasks are completed, the thread sleeping due to the await() method will be awakened.

Here I have made some improvements based on the CountDownLatch usage example in the Java 7 Concurrent Programming Practical Manual to demonstrate the usage details of CountDownLatch:

Simulate a meeting with 10 participants and a moderator. Each participant and moderator need to wait for other participants to sign in before they can start the meeting and speak. To do this, first create a class VideoConference that will be managed, which provides an arrive() method for participants to call to check in. The owner of the conference management is the host, who waits for each participant to sign in:

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

Create a participant class 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(); 
    } 
  } 
}

The main function in the Participant class First create a meeting that requires 10 participants to participate. Then, create 10 participants and sign in one by one. After all 10 participants sign in, each participant and host will Be "awakened" and speak.

Summary:

The CountDownLatch class solves the problem of synchronization waiting and task coordination between multiple threads. It can be used when starting a program. Before the main function, multiple subtasks such as configuration environment check, network check, etc. need to be completed in advance and similar scenarios. In Java, in addition to using CountDownLatch to achieve synchronous waiting between multiple threads, you can also use barrier technology CyclicBarrier to achieve synchronous waiting and task coordination between multiple threads.

The above is the detailed content of Example code sharing of CountDownLatch for multi-thread synchronization in Java. For more information, please follow other related articles on the PHP Chinese website!