Java中的Semaphore

Semaphore 是 Java 并发包（java.util.concurrent）中的核心同步工具类，用于​​控制对共享资源的并发访问数量​​，通过“许可证”机制实现资源限流。下面从多个维度全面解析其设计原理和应用实践。

🔧 ​​一、基本概念与核心原理​​

📌 ​​1. 核心模型​​

• ​​信号量模型​​：
  Semaphore 维护一个​​许可证计数器​​（permits），通过原子操作控制资源访问：
  • ​​acquire()​​（P操作）：申请许可证，计数器减 1；若无可用许可证，线程阻塞。
  • ​​release()​​（V操作）：释放许可证，计数器加 1，唤醒阻塞线程。
• ​​公平性​​：
  • ​​非公平模式（默认）​​：允许线程插队获取许可，吞吐量高但可能引发线程饥饿。
  • ​​公平模式​​：按 FIFO 顺序分配许可，避免饥饿但性能较低。

⚙️ ​​2. 底层实现​​

基于 ​​AQS（AbstractQueuedSynchronizer）​​ 的共享锁模式实现：

• ​​状态变量​​：AQS 的 state 字段存储当前可用许可证数量。
• ​​关键源码逻辑​​：

  // 非公平模式尝试获取许可
  final int nonfairTryAcquireShared(int acquires) {
      for (;;) {
          int available = getState();
          int remaining = available - acquires;
          if (remaining < 0 || compareAndSetState(available, remaining)) 
              return remaining; // 负数表示获取失败
      }
  }
  // 释放许可
  protected final boolean tryReleaseShared(int releases) {
      for (;;) {
          int current = getState();
          int next = current + releases;
          if (compareAndSetState(current, next)) 
              return true; // 唤醒阻塞线程
      }
  }

🛠️ ​​二、使用方式与代码示例​​

📝 ​​1. 基础用法​​

import java.util.concurrent.Semaphore;

public class PrinterService {
    private final Semaphore semaphore = new Semaphore(3); // 初始化3个许可证

    public void printDocument(String docName) throws InterruptedException {
        semaphore.acquire(); // 获取许可（阻塞直到可用）
        try {
            System.out.println("Printing: " + docName);
            Thread.sleep(1000); // 模拟打印耗时
        } finally {
            semaphore.release(); // 必须释放许可！
        }
    }
}

⏱ ​​2. 高级方法：超时与批量操作​​

// 尝试获取许可（超时控制）
if (semaphore.tryAcquire(2, 500, TimeUnit.MILLISECONDS)) {
    try {
        // 执行任务
    } finally {
        semaphore.release(2); // 释放多个许可
    }
} else {
    System.out.println("获取许可超时！");
}

🌐 ​​3. 多线程场景示例​​

public static void main(String[] args) {
    PrinterService service = new PrinterService();
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            try {
                service.printDocument("Doc-" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

​​输出效果​​：

Printing: Doc-Thread-0  
Printing: Doc-Thread-1  
Printing: Doc-Thread-2  // 仅3个线程并发执行  
Thread-2 释放许可 → Thread-3 开始打印  
...  

⚖️ ​​三、优缺点分析​​

🎯 ​​四、适用场景​​

🔌 ​​1. 资源池管理​​

• ​​数据库连接池​​：限制同时使用的连接数，防止连接耗尽。

  public class ConnectionPool {
      private final Semaphore semaphore = new Semaphore(MAX_CONNECTIONS);
      private final BlockingQueue<Connection> pool = new LinkedBlockingQueue<>();
  
      public Connection borrow() throws InterruptedException {
          semaphore.acquire();
          return pool.take();
      }
      public void release(Connection conn) {
          pool.offer(conn);
          semaphore.release();
      }
  }

🚦 ​​2. 流量控制​​

• ​​API 限流​​：限制每秒请求数，防止服务雪崩。

  public class RateLimiter {
      private final Semaphore semaphore = new Semaphore(100); // 每秒100个请求
      private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
  
      public RateLimiter() {
          scheduler.scheduleAtFixedRate(() -> 
              semaphore.release(semaphore.drainPermits()), 1, 1, TimeUnit.SECONDS);
      }
      public void callAPI(Runnable task) throws InterruptedException {
          semaphore.acquire();
          task.run();
      }
  }

🖨 ​​3. 物理资源共享​​

• ​​打印机/文件系统​​：控制多线程访问共享硬件资源。

  semaphore.acquire();
  try {
      Files.write(Paths.get("log.txt"), data, StandardOpenOption.APPEND);
  } finally {
      semaphore.release();
  }

⚠️ ​​五、注意事项与最佳实践​​

1. ​​避免许可证泄漏​​：
   • 确保 release() 在 finally 块中调用，防止异常导致许可未释放。
2. ​​合理选择公平性​​：
   • 高吞吐场景用非公平模式，严格顺序需求用公平模式。
3. ​​控制许可证数量​​：
   • 过多导致资源浪费，过少引发线程饥饿（通过监控 availablePermits() 动态调整）。
4. ​​避免嵌套死锁​​：
   • 若需多信号量，按固定顺序获取（如先 A 后 B），防止交叉等待。

💎 ​​总结​​

Semaphore 是解决​​资源并发控制​​的利器，尤其适合​​读多写少、资源池限流、API控频​​等场景。其基于 AQS 的实现兼顾了灵活性与性能，但需注意许可证管理的原子性和释放的可靠性。在高并发系统中，合理使用 Semaphore 能有效提升系统稳定性与资源利用率🔥。