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();
  }

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

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

总结​​

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

到此这篇关于Java中的Semaphore(信号量)的文章就介绍到这了,更多相关Java中Semaphore内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！