How to use Java multi-thread synchronization tool class CountDownLatch

Introduction

CountDownLatch is a multi-thread synchronization tool class. In a multi-thread environment, it allows multiple threads to wait until the execution of the previous thread ends. Judging from the class name, CountDown means decrementing the number, and we can understand it as a counter.

Core method

• countDown(): Counter decrement method.

• await(): Puts the thread calling this method into a waiting state. The main thread will not be awakened until the counter reaches 0.

• await(long, TimeUnit): A timeout strategy is added based on the await() method. If the wait timeout does not occur, The result will directly wake up the main thread to run.

How to use CountDownLatch

Here we use a simple code to demonstrate:

@Slf4j
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        new Thread(() -> {
            log.info("hello this is thread one");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            log.info("hello this is thread two");
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            log.info("hello this is thread three");
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        log.info("say good bye!");
    }
}

As can be seen from the above code , we created a CountDownLatch counter with a value of 3 and three threads running simultaneously. The countDownLatch.await() method is called in the main thread to cause the main thread to enter blocking. After three thread tasks are executed, the countDownLatch.countDown() method will be called to decrement the counter. When all three thread tasks are executed, the counter value reaches 0 and the main thread is awakened.

Note: The counter value must be defined when creating a CountDownLatch instance. Generally, a relatively reasonable usage is that the definition of the value requires reasonable calculation. The count value is equal to the number of threads that need to be parallelized. After each thread is completed, the count is decremented, and finally the main thread is awakened to continue execution.

• CountDownLatchThe count value is set to be greater than the number of threads, then all threads will eventually finish executing, and the count will decrease to 0, then the main thread will always be in Waiting state.

• CountDownLatchThe count value is set to be less than the number of concurrent threads. Then the count may have been decremented to 0 before some threads have completed execution, and the main thread will be advanced. wake.

CountDownLatch operation process

As shown in the figure below, the core of the main thread blocking and waking up is the counter. Only when all threads have completed execution and the counts are decremented one by one will they finally be awakened await()The main thread is blocking.

Note: await() can block one thread or multiple threads. If multiple threads are blocked, the count will be 0 will wake up all blocked threads.

Use scenarios

After briefly understanding the role of CountDownLatch, I believe that your ultimate goal is to know how to Use and in which scenarios it is more appropriate to use it. Next, I will take a reconciliation business scenario and analyze it in detail.

Under the current circumstances, many platforms will connect transactions with payment channels such as UnionPay, WeChat, and Alipay, so reconciliation is unavoidable. Reconciliations are usually processed in the early morning of each day. On the one hand, most platforms have smaller visits in the early morning hours, and the server pressure is relatively relaxed, and the accounts are more reasonable at this time, so it is also appropriate to do reconciliation at this time. A large data volume calculation operation.

It seems that the above mentioned points are not mentioned. Before processing the reconciliation, we must first obtain the statement files through various payment channels. So how to operate?

• Reconciliation file download (first phase) : In this case, three tasks can be designed to obtain the reconciliation file concurrently, using CountDownLatch Block the main thread, wait for all three tasks to obtain the file, and decrement the count. Finally, waking up the main thread will mark the completion of this stage of processing and initiate a notification to enter the next stage.

• Reconciliation file parsing (second phase): In the file that has been downloaded in the previous stage, what needs to be done in this stage is to parse the file. Since the three channels are from different manufacturers, the content format of the files must be different. At this time, we can use CountDownLatch to start three threads to parse their respective reconciliation files, and finally convert the files The content is converted into the data required by the business in a unified format and stored in the database. After all three tasks are stored in the database, the main thread is awakened and marked as completed, notifying the next stage to start work.

• Reconciliation and Settlement (Third Stage): After the data in the previous stage is entered into the database, what needs to be done in this stage is to compare whether each transaction is accurate. Generally, the transaction amount is compared based on the order number and the transaction channel. If the amounts are consistent, the transaction is settled successfully. Otherwise, the transaction is judged as an abnormal transaction and stored in the database for processing. From the above process analysis, we can design a relatively reasonable CountDownLatch count, combine it with the Semaphore semaphore to control the concurrency, and concurrently process the comparison transaction orders, and finally complete the processing of all transaction orders. Then wake up the main thread to mark the completion of the reconciliation and notify the next stage to proceed with the accounting.

• Issuing accounts (the fourth stage): Usually the platform will issue accounts after the reconciliation is completed, that is, it is convenient to issue relevant bills according to the business rules of the platform Finance staff perform statistics.

The above is the detailed content of How to use Java multi-thread synchronization tool class CountDownLatch. For more information, please follow other related articles on the PHP Chinese website!