Semaphore 有什么用

一句话总结

Semaphore 是用于控制多线程/进程对共享资源访问的同步机制。通过维护计数器实现资源管理，提供 wait() 和 signal() 操作协调线程执行顺序。主要解决并发场景下的互斥访问（二进制信号量）和资源数量限制（计数信号量）问题，防止数据竞争和系统资源耗尽。

详细解析

一、核心功能：资源并发控制

Semaphore（信号量） 是 Java 并发包中用于 控制同时访问共享资源的线程数量 的同步工具。其核心机制是通过 许可证（Permits） 的获取与释放，实现线程的并发调度。
核心价值：
o 限制资源过载（如数据库连接池、线程池）

o 实现流量控制（如 API 限流）

o 协调多线程协作（如生产者-消费者模型）

二、核心应用场景

1. 限流与资源保护
   o 场景：限制同时访问某个服务的线程数（如 API 接口限流）。

o 实现：初始化 Semaphore 的许可数为最大并发量，线程执行前需获取许可。

  Semaphore semaphore = new Semaphore(100); // 允许 100 个并发请求
  public void handleRequest() {
      semaphore.acquire();
      try {
          // 处理请求
      } finally {
          semaphore.release();
      }
  }

优势：避免系统因突发流量崩溃。

2.资源池管理

o 场景：控制数据库连接、线程池等有限资源的并发使用。

o 实现：许可数等于资源池容量。

  // 数据库连接池示例
  Semaphore dbConnectionPool = new Semaphore(10); // 最大 10 个连接
  Connection getConnection() throws InterruptedException {
      dbConnectionPool.acquire();
      return dataSource.getConnection();
  }
  void releaseConnection(Connection conn) {
      conn.close();
      dbConnectionPool.release();
  }

优势：防止资源耗尽。

3.多线程限量执行

o 场景：控制同时执行的任务数量（如批量处理）。

o 实现：通过acquire()和release()动态调整并发度。

  // 限制同时处理的任务数为 5
  Semaphore taskSemaphore = new Semaphore(5);
  for (int i = 0; i < 100; i++) {
      new Thread(() -> {
          taskSemaphore.acquire();
          try {
              processTask();
          } finally {
              taskSemaphore.release();
          }
      }).start();
  }

优势：平衡资源占用与处理效率。

4.生产者-消费者模型

o 场景：协调生产者和消费者的执行节奏。

o实现：通过信号量控制缓冲区容量。

  Semaphore emptySlots = new Semaphore(10); // 缓冲区容量 10
  Semaphore filledSlots = new Semaphore(0);

  // 生产者
  void produce() throws InterruptedException {
      emptySlots.acquire();
      addToBuffer();
      filledSlots.release();
  }

  // 消费者
  void consume() throws InterruptedException {
      filledSlots.acquire();
      removeFromBuffer();
      emptySlots.release();
  }

优势：避免生产者过快或消费者过慢导致的阻塞。

5.实现互斥锁

o 场景：将 Semaphore 退化为互斥锁（独占模式）。

o 实现：初始化许可数为 1。

  Semaphore mutex = new Semaphore(1);
  public void criticalSection() throws InterruptedException {
      mutex.acquire();
      try {
          // 临界区代码
      } finally {
          mutex.release();
      }
  }

优势：相比synchronized，支持公平性配置。

三、与锁的对比

四、底层实现原理

1. AQS 框架：Semaphore 基于AbstractQueuedSynchronizer实现，通过state变量记录可用许可数。
2. 队列管理：使用 CLH 队列管理等待线程，非公平模式下新线程可能抢占许可。
3. CAS 操作：通过compareAndSetState()保证许可数修改的原子性。

五、实际代码示例（带超时与异常处理）

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    private static final Semaphore semaphore = new Semaphore(3, true); // 公平模式，3 个许可

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Worker(i)).start();
        }
    }

    static class Worker implements Runnable {
        private final int id;

        Worker(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            try {
                System.out.println("Worker-" + id + " 正在申请资源...");
                if (semaphore.tryAcquire(2, 1, TimeUnit.SECONDS)) { // 尝试获取 2 个许可，超时 1 秒
                    try {
                        System.out.println("Worker-" + id + " 获取资源，开始工作...");
                        Thread.sleep(2000);
                    } finally {
                        semaphore.release(2);
                        System.out.println("Worker-" + id + " 释放资源");
                    }
                } else {
                    System.out.println("Worker-" + id + " 获取资源超时");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}