在现代的多线程编程中，Semaphore和CountDownLatch是两个非常常见和重要的工具类，它们都可以用来实现多线程间的同步和互斥，提高程序的并发性能和效率。本文将详细介绍Java中的Semaphore和CountDownLatch这两个工具类的使用方法和实际应用场景。
一、Semaphore
1.1 概述
Semaphore是Java中的一个同步工具类，用来控制多个线程对共享资源的访问。它主要用于控制并发线程的数量，可以设置一定数量的许可证，每当一个线程访问共享资源时，会消耗一个许可证，当许可证用尽时，其他线程就会被阻塞，直到有线程释放许可证为止。
1.2 使用
Semaphore的常用方法如下：
- acquire(int permits): 获取指定数量的许可证，如果没有足够的许可证，当前线程将会被阻塞。
- tryAcquire(int permits): 尝试获取指定数量的许可证，如果可以获取则返回true，否则返回false。
- release(int permits): 释放指定数量的许可证，唤醒被阻塞的线程。
使用Semaphore的典型场景是控制线程的并发数量，下面我们来看一个简单的例子：
代码语言：java复制import java.util.concurrent.Semaphore;
public class SemaphoreTest {
public static void main(String[] args) {
int N = 8; // 任务数
Semaphore semaphore = new Semaphore(5); // 最大并发数为5
for (int i = 0; i < N; i ) {
new Worker(i, semaphore).start(); // 启动多个线程
}
}
static class Worker extends Thread {
private int num;
private Semaphore semaphore;
public Worker(int num, Semaphore semaphore) {
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire(); // 获取许可证
System.out.println("Worker " num " is working");
Thread.sleep(2000);
System.out.println("Worker " num " has finished");
semaphore.release(); // 释放许可证
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}上面的代码中，我们创建了一个Semaphore对象，并设置最大并发数为5。然后创建了8个线程，每当一个线程开始工作时，需要先获取一个许可证，如果没有足够的许可证，则会被阻塞，直到其他线程释放许可证为止。这样就可以有效控制线程的并发数量，避免系统资源过度消耗。
二、CountDownLatch
2.1 概述
CountDownLatch也是Java中的一个同步工具类，它用于控制一个或多个线程等待其他线程完成任务后再执行。CountDownLatch的工作方式比较简单，它会在初始化时设置一个计数器，每当一个任务完成时，就将计数器减一；当计数器为0时，代表所有任务都已经完成，等待的线程可以开始执行了。
2.2 使用
CountDownLatch的常用方法如下：
- CountDownLatch(int count)：初始化一个CountDownLatch对象，并设置计数器初始值。
- void await()：调用此方法会使当前线程等待，直到计数器为0才继续执行。
- void countDown()：将计数器减1，当计数器为0时，等待的线程会被唤醒。
下面我们来看一个实际应用场景，假设要求在多个线程中进行文件拆分和合并操作，需要先将文件拆分成若干个块，然后多个线程并行处理这些块，最后再将处理结果合并成一个完整的文件。这个需求可以使用CountDownLatch来实现。
代码语言：java复制import java.util.concurrent.CountDownLatch;
public class CountDownLatchTest {
private static final int THREAD_COUNT = 4; // 线程数
private static final CountDownLatch startLatch = new CountDownLatch(1); // 开始信号
private static final CountDownLatch endLatch = new CountDownLatch(THREAD_COUNT); // 结束信号
public static void main(String[] args) {
for (int i = 0; i < THREAD_COUNT; i ) {
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() " is ready");
startLatch.await(); // 等待开始信号
System.out.println(Thread.currentThread().getName() " is working");
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() " has finished");
endLatch.countDown(); // 发送结束信号
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
System.out.println("All threads are ready, start working...");
startLatch.countDown(); // 发送开始信号
try {
endLatch.await(); // 等待所有线程结束
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("All threads have finished their work");
}
}上面的代码中，我们创建了4个线程，并使用CountDownLatch来控制线程的同步和互斥。首先创建了两个CountDownLatch对象，一个用于发出开始信号，一个用于接收结束信号。然后启动了4个线程，每当一个线程开始工作时，需要等待开始信号发出，如果没有收到开始信号，则会一直等待；当所有线程都已经完成任务后，需要发送结束信号，以便主线程可以继续执行。
三、总结
通过以上示例，我们可以看到在实际应用中，Semaphore和CountDownLatch也都是非常实用的工具类，它们可以帮助程序员有效控制多线程的并发数量和任务执行顺序，提高程序的性能和效率。有了这两个工具类的帮助，我们可以更加方便地进行多线程编程，实现更加复杂的业务逻辑。需要注意的是，在使用这两个工具类时，应该结合实际需求场景来选择合适的方法和参数，避免程序出现不必要的死锁和阻塞。
