CountDownLatch 与信号量

AI

的文章如下：

CountDownLatch与信号量

在并发编程中，CountDownLatch和信号量是两个重要的工具，用于控制多线程之间的协作和同步。本文将介绍CountDownLatch和信号量的概念及其在实际应用中的使用。

CountDownLatch是一种同步工具，它可以让一个或多个线程等待其他线程完成操作后再继续执行。CountDownLatch内部维护了一个计数器，当计数器的值为0时，等待的线程会被唤醒。在CountDownLatch中，主线程可以调用awAIt()方法来等待其他线程完成任务，而其他线程完成任务后可以调用countDown()方法来将计数器的值减1。

信号量是一种控制并发访问资源的工具，它可以限制同时访问某个资源的线程数量。信号量内部维护了一个计数器，当计数器的值大于0时，线程可以继续执行，当计数器的值为0时，线程需要等待。在信号量中，线程可以通过acquire()方法来申请资源，而其他线程释放资源后可以通过release()方法来增加计数器的值。

CountDownLatch的应用场景

CountDownLatch常用于一些需要等待其他线程完成后再继续执行的场景。例如，一个主线程需要等待多个子线程完成任务后再进行下一步操作。下面是一个使用CountDownLatch的示例代码：

Java
import Java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
    public static void mAIn(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch latch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {</p>            new Thread(() -> {
                // 模拟子线程执行任务
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程执行任务完成");
                latch.countDown();
            }).start();
        }
        System.out.println("等待子线程执行任务...");
        latch.awAIt();
        System.out.println("所有子线程执行任务完成，继续执行主线程");
    }
}

在上面的代码中，主线程创建了一个CountDownLatch对象，并将计数器的初始值设置为子线程的数量。然后，主线程通过调用awAIt()方法等待子线程完成任务。在子线程中，模拟了执行任务的过程，并在任务完成后调用countDown()方法将计数器的值减1。当所有子线程都完成任务后，主线程被唤醒，继续执行下一步操作。

信号量的应用场景

信号量常用于控制并发访问资源的数量。例如，一个资源只能同时被固定数量的线程访问，其他线程需要等待。下面是一个使用信号量的示例代码：

Java
import Java.util.concurrent.Semaphore;
public class SemaphoreExample {
    public static void mAIn(String[] args) {
        int threadCount = 10;
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {</p>            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("线程" + Thread.currentThread().getName() + "获取到资源");
                    Thread.sleep(1000);
                    System.out.println("线程" + Thread.currentThread().getName() + "释放资源");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

在上面的代码中，创建了一个Semaphore对象，并将资源的数量设置为3。然后，创建了10个线程，每个线程先通过acquire()方法申请资源，获取到资源后执行任务，并在任务完成后通过release()方法释放资源。由于资源的数量为3，所以最多只能有3个线程同时获取到资源，其他线程需要等待。

：

CountDownLatch和信号量是两个在并发编程中常用的工具，它们可以帮助我们控制多线程之间的协作和同步。CountDownLatch适用于主线程需要等待其他线程完成后再继续执行的场景，而信号量适用于控制并发访问资源的数量的场景。在实际应用中，我们可以根据具体的需求选择使用CountDownLatch或信号量来实现多线程的协作和同步。