Semaphore、CountDownLatch、ReentrantLock使用场景简单说说

目录

• 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(); // 解锁