【CountDownLatch 和 Semaphore】

介绍：

CountDownLatch 和 Semaphore 都是 Java 多线程编程中的同步工具，用于控制线程的执行顺序和对共享资源的访问控制。

CountDownLatch 是一个计数器，允许一个或多个线程等待其他线程完成操作后再执行。在 CountDownLatch 初始化时设置一个计数器，每个线程完成任务后将计数器减 1，当计数器变为 0 时，等待的线程将被唤醒。

Semaphore 是一个信号量，用于控制同时访问共享资源的线程数量。Semaphore 在初始化时设置一个许可证数量，表示可以同时访问资源的线程数量，每个线程访问资源前需要获取一个许可证，访问结束后释放该许可证。

区别：

CountDownLatch 和 Semaphore 在功能上有一些区别，CountDownLatch 用于等待其他线程完成某个操作，而 Semaphore 则用于限制同时访问共享资源的线程数量。

在实现上，CountDownLatch 只能使用一次，即计数器减为 0 后不能再次使用，而 Semaphore 可以重复使用，即许可证数量可以被释放和重新获取。

另外，CountDownLatch 计数器的初始值是固定的，而 Semaphore 的许可证数量可以动态调整。

CountDownLatch

import java.util.concurrent.CountDownLatch;

/**
 * 在这个示例中，我们创建了一个 CountDownLatch 对象，并将其初始化为 5。
 * 然后，我们创建了 5 个线程，并在每个线程中调用 countDown 方法，以表示该线程已完成其任务。
 * 最后，我们调用 await 方法来等待所有线程完成任务，并输出 "All threads completed"。
 *
 * countDownLatch.countDown():表示该线程已完成其任务
 * countDownLatch.await()    :等待所有线程完成任务
 */
public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int numOfThreads = 5;
        CountDownLatch countDownLatch = new CountDownLatch(numOfThreads);

        for (int i = 0; i < numOfThreads; i++) {
            new Thread(() -> {
                System.out.println("Thread " + Thread.currentThread().getId() + " started");
                countDownLatch.countDown();
                System.out.println("Thread " + Thread.currentThread().getId() + " completed");
            }).start();
        }

        countDownLatch.await();
        System.out.println("All threads completed");
    }
}

Semaphore

import java.util.concurrent.Semaphore;

/**
 * 在这个示例中，我们创建了一个 Semaphore 对象，并将其初始化为 3。然后，我们创建了 5 个线程，
 * 并在每个线程中调用 acquire 方法来获取许可证。如果许可证数量已达到 3 个，则线程将被阻塞直到有一个许可证可用.
 * 当线程完成其任务后，它将调用 release 方法来释放许可证，并使其可用于其他线程。
 *
 * 在这个示例中，我们使用 Thread.sleep 来模拟每个线程完成其任务所需的时间。
 *
 * semaphore.acquire():获取许可证
 * semaphore.release():释放许可证
 */
public class SemaphoreExample {
    public static void main(String[] args) {
        int numOfPermits = 3;
        Semaphore semaphore = new Semaphore(numOfPermits);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread " + Thread.currentThread().getId() + " acquired a permit");
                    Thread.sleep(1000);
                    semaphore.release();
                    System.out.println("Thread " + Thread.currentThread().getId() + " released a permit");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}