java - 在Java中使用异步后，主方法如何返回异步中得到的值？ - SegmentFault 思否

使用CountDownLatch 可以将异步操作，转换为同步操作。

CountDownLatch is a class in Java that allows one or more threads to wait until a set of operations performed by other threads completes. It is useful for synchronizing concurrent tasks, such as parallel processing or testing¹²³.

A CountDownLatch has a counter that is initialized with a positive number, usually the number of threads that need to finish their work. Each thread can call the countDown() method to decrement the counter by one when it is done. The thread that calls the await() method will block until the counter reaches zero, meaning that all the other threads have completed their tasks.

Here are some examples of how to use CountDownLatch in Java:

• To make the main thread wait for several worker threads to finish their work, you can create a CountDownLatch with the same value as the number of worker threads, and pass it to each thread. The worker threads will call countDown() when they are done, and the main thread will call await() to wait for them. This way, you can ensure that the main thread will resume only after all the worker threads have finished.
• To make several threads start their tasks at the same time, you can create a CountDownLatch with a value of one, and pass it to each thread. The threads will call await() before they start their tasks, and the main thread will call countDown() to signal them to start. This way, you can achieve maximum parallelism among the threads, as they will all start at the same moment.

give examples

Sure, here are some examples of how to use CountDownLatch in Java:

To make the main thread wait for several worker threads to finish their work, you can use the following code:

// Create a CountDownLatch with the same value as the number of worker threads
CountDownLatch latch = new CountDownLatch(4);

// Create and start four worker threads, passing the latch to each one
for (int i = 0; i < 4; i++) {
    new Thread(new Worker(latch)).start();
}

// Wait for the latch to count down to zero
latch.await();

// Resume the main thread after all the worker threads have finished
System.out.println("All workers done");

To make several threads start their tasks at the same time, you can use the following code:

// Create a CountDownLatch with a value of one
CountDownLatch startSignal = new CountDownLatch(1);

// Create and start four runner threads, passing the start signal to each one
for (int i = 0; i < 4; i++) {
    new Thread(new Runner(startSignal)).start();
}

// Wait for a few seconds before signaling the start
Thread.sleep(3000);

// Call countDown() to signal the start of the race
startSignal.countDown();

// The main thread does not need to wait for the runners to finish
System.out.println("Race started");