目录
- Semaphore、CountDownLatch、ReentrantLock使用场景简单说说
- 1. Semaphore（信号量）
- 2. CountDownLatch（倒计时门闩）
- 3. ReentrantLock（可重入锁）
- 对比总结
- 简单记忆
- 三个并发工具的简单示例
- 1. Semaphore 示例 - 停车场系统
- 2. CountDownLatch 示例 - 比赛准备
- 3. ReentrantLock 示例 - 银行取款
- 一句话总结
Semaphore、CountDownLatch、ReentrantLock使用场景简单说说
1. Semaphore（信号量）
核心思想：控制并发访问资源的线程数量（资源池）
典型场景：
// 1. 数据库连接池（控制最大连接数）
Semaphore semaphore = new Semaphore(10); // 最多10个并发连接// 2. 限流（接口限流、流量控制）
Semaphore rateLimiter = new Semaphore(100); // QPS限制为100// 3. 停车场系统（有限停车位）
Semaphore parkingSpots = new Semaphore(50); // 50个车位
关键点：acquire()获取许可，release()释放许可，可指定许可数量。
2. CountDownLatch（倒计时门闩）
核心思想：让一个或多个线程等待其他线程完成操作
典型场景：
// 1. 主线程等待所有子线程初始化完成
CountDownLatch latch = new CountDownLatch(5);
// 每个子线程完成时调用 latch.countDown()
// 主线程调用 latch.await() 等待// 2. 并行计算，汇总结果
// 3. 模拟并发测试（同时发起请求）
// 4. 游戏等待所有玩家准备就绪
关键点：一次性使用，计数减到0后所有等待线程被唤醒。
3. ReentrantLock（可重入锁）
核心思想：替代synchronized的显式锁，提供更灵活的锁控制
典型场景：
// 1. 需要尝试获取锁（避免死锁）
if (lock.tryLock(3, TimeUnit.SECONDS)) {try {// 临界区} finally {lock.unlock();}
}// 2. 公平锁需求（按申请顺序获取锁）
ReentrantLock fairLock = new ReentrantLock(true);// 3. 需要条件变量的复杂同步
Condition condition = lock.newCondition();
condition.await(); // 等待条件
condition.signal(); // 唤醒// 4. 可中断的锁获取
lock.lockInterruptibly();
对比总结
| 工具 | 核心用途 | 是否可重用 | 关键特性 |
|---|---|---|---|
| Semaphore | 控制资源访问并发数 | 是 | 许可机制，可增可减 |
| CountDownLatch | 等待其他线程完成 | 否（一次性） | 倒计时，不可重置 |
| ReentrantLock | 替代synchronized的互斥锁 | 是 | 可重入、可中断、公平/非公平、条件变量 |
简单记忆
- Semaphore：流量控制（多少辆车能上高速）
- 核心思想：控制并发访问资源的线程数量（资源池）
- CountDownLatch：起跑线（等所有运动员就位）
- 核心思想：让一个或多个线程等待其他线程完成操作
- ReentrantLock：加强版synchronized（需要更精细控制时用）
- 核心思想：替代
synchronized的显式锁，提供更灵活的锁控制
- 核心思想：替代
根据具体需求选择：
- 需要限流/资源池 → Semaphore
- 需要等待多个任务完成 → CountDownLatch
- 需要灵活的锁控制 → ReentrantLock
三个并发工具的简单示例
1. Semaphore 示例 - 停车场系统
import java.util.concurrent.Semaphore;public class ParkingLot {public static void main(String[] args) {Semaphore parkingSpots = new Semaphore(3); // 只有3个停车位// 5辆车尝试停车for (int i = 1; i <= 5; i++) {new Thread(() -> {try {parkingSpots.acquire(); // 获取停车位System.out.println(Thread.currentThread().getName() + " 停入车位");Thread.sleep(2000); // 停车2秒System.out.println(Thread.currentThread().getName() + " 离开车位");parkingSpots.release(); // 释放停车位} catch (InterruptedException e) {e.printStackTrace();}}, "车辆" + i).start();}}
}
输出结果：
车辆1 停入车位
车辆2 停入车位
车辆3 停入车位
（等待...）
车辆1 离开车位
车辆4 停入车位
车辆2 离开车位
车辆5 停入车位
...
2. CountDownLatch 示例 - 比赛准备
import java.util.concurrent.CountDownLatch;public class Race {public static void main(String[] args) throws InterruptedException {CountDownLatch readySignal = new CountDownLatch(3); // 3个运动员System.out.println("裁判：各就各位！");// 3个运动员线程for (int i = 1; i <= 3; i++) {new Thread(() -> {System.out.println(Thread.currentThread().getName() + " 准备就绪");readySignal.countDown(); // 计数减1}, "运动员" + i).start();}readySignal.await(); // 裁判等待所有运动员就位System.out.println("裁判：预备...跑！");}
}
输出结果：
裁判：各就各位！
运动员1 准备就绪
运动员2 准备就绪
运动员3 准备就绪
裁判：预备...跑！
3. ReentrantLock 示例 - 银行取款
import java.util.concurrent.locks.ReentrantLock;public class BankAccount {private int balance = 1000;private ReentrantLock lock = new ReentrantLock();// 取款操作public boolean withdraw(int amount) {lock.lock(); // 手动加锁try {if (balance >= amount) {Thread.sleep(100); // 模拟处理时间balance -= amount;System.out.println(Thread.currentThread().getName() + " 取款" + amount + "，余额：" + balance);return true;}return false;} catch (InterruptedException e) {e.printStackTrace();return false;} finally {lock.unlock(); // 必须在finally中解锁！}}public static void main(String[] args) {BankAccount account = new BankAccount();// 两个人同时取款new Thread(() -> account.withdraw(800), "张三").start();new Thread(() -> account.withdraw(800), "李四").start();}
}
输出结果：
张三 取款800，余额：200
李四 取款失败（余额不足）
注意：如果没有锁，可能两人都取款成功，导致余额为负数！
一句话总结
// Semaphore：控制数量（最多N个同时访问）
Semaphore sem = new Semaphore(5); // 最多5个// CountDownLatch：等待完成（等N个完成后继续）
CountDownLatch latch = new CountDownLatch(3); // 等3个// ReentrantLock：替代synchronized（手动加锁解锁）
lock.lock(); // 加锁
lock.unlock(); // 解锁