使用countdownlatch与CompleteFuture实现同步等待的区别

使用CountDownLatch和CompletableFuture都可以实现同步等待的功能，但是它们的实现方式有所不同。CountDownLatch是一种基于计数器的同步工具，可以让一个或多个线程等待其他线程完成操作后再执行。而CompletableFuture是一种异步编程的方式，可以让我们在一个线程中等待另一个线程的结果，而不需要阻塞当前线程。此外，CompletableFuture还支持链式调用和异常处理等功能，更加灵活和方便。

相关问题

如何在Java中结合CountDownLatch与线程池实现同步任务执行？

在Java中，结合`CountDownLatch`与线程池可以实现同步任务执行。`CountDownLatch`是一个同步辅助工具，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。以下是一个示例，展示了如何结合`CountDownLatch`与线程池实现同步任务执行：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {

    public static void main(String[] args) {
        // 创建一个CountDownLatch，初始计数为3
        CountDownLatch latch = new CountDownLatch(3);
        
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        // 提交三个任务到线程池
        executor.execute(new Task(latch, "Task 1"));
        executor.execute(new Task(latch, "Task 2"));
        executor.execute(new Task(latch, "Task 3"));
        
        try {
            // 等待所有任务完成
            latch.await();
            System.out.println("All tasks are completed.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executor.shutdown();
        }
    }

    static class Task implements Runnable {
        private CountDownLatch latch;
        private String name;

        public Task(CountDownLatch latch, String name) {
            this.latch = latch;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                System.out.println(name + " is running.");
                // 模拟任务执行时间
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 任务完成，计数器减1
                latch.countDown();
                System.out.println(name + " is completed.");
            }
        }
    }
}

在这个示例中：

1. 创建一个`CountDownLatch`，初始计数为3，表示有三个任务需要完成。
2. 创建一个固定大小的线程池`ExecutorService`，并提交三个任务到线程池。
3. 每个任务在执行完成后调用`latch.countDown()`，将计数器减1。
4. 主线程调用`latch.await()`，等待计数器变为0，表示所有任务完成。
5. 最后关闭线程池。

使用CountDownLatch

CountDownLatch是Java中的一个同步工具类，它可以让一个或多个线程等待其他线程完成操作后再执行。下面是一个使用CountDownLatch的示例：

import java.util.concurrent.CountDownLatch;

public class Example {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                // 线程执行的操作
                System.out.println(Thread.currentThread().getName() + " 执行完毕");
                latch.countDown();
            }).start();
        }

        latch.await();
        System.out.println("所有线程执行完毕");
    }
}

上面的示例中，我们创建了一个CountDownLatch对象，并将计数器初始化为5。然后创建了5个线程，每个线程执行完毕后都会调用countDown()方法来减少计数器的值。最后，主线程调用await()方法来等待所有线程执行完毕。