基本概念

在并发编程中，Semaphore（信号量）是一种用于控制访问共享资源的工具。它通过内部计数器来实现对资源的访问控制，可以控制同时访问特定资源的线程数量。Semaphore 可以用于限制并发访问的线程数量，常用于生产者-消费者问题、连接池控制等场景。
Semaphore 是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore 可以用来构建一些对象池，资源池之类的，比如数据库连接池
Java 中的 Semaphore 是一种新的同步类，它是一个计数信号。从概念上讲， 从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每 一个 acquire()，然后再获取该许可。每个 release()添加一个许可，从而可 能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只 对可用许可的号码进行计数，并采取相应的行动。信号量常常用于多线程的代 码中，比如数据库连接池
实现互斥锁（计数器为 1），我们也可以创建计数为 1 的 Semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。
Semaphore 是一种强大的并发控制工具，广泛用于限制并发线程数、控制共享资源的访问以及解决生产者-消费者问题。通过合理配置许可数和选择公平或非公平模式，可以根据应用的不同需求进行灵活的并发控制。

信号量（Semaphore） 是一种同步工具，通常用于限制并发访问资源的数量。
信号量内部持有一个计数器，该计数器表示可以允许多少个线程同时访问某个共享资源。
每当一个线程尝试访问资源时，信号量的计数器会减一；当线程访问完毕后，信号量的计数器会加一，表示一个资源位置被释放。

工作原理

获取资源 (acquire())：如果信号量的计数器大于 0，线程可以获取资源，计数器减一。如果计数器为 0，线程就会被阻塞，直到其他线程释放资源。
释放资源 (release())：当线程访问完共享资源后，调用 release() 方法，信号量的计数器加一，释放一个资源位置。如果有线程因为信号量的计数器为 0 而被阻塞，释放信号量会唤醒其中一个线程。
Semaphore 类构造函数

public class Semaphore {// 构造函数public Semaphore(int permits) {// 创建一个信号量，初始许可数为 permits}public Semaphore(int permits, boolean fair) {// 创建一个公平信号量，初始许可数为 permits}
}

permits：表示信号量的许可数，即可以同时允许多少个线程访问资源。
fair：如果设置为 true，表示公平模式，线程将按请求的顺序获取许可。默认情况下是 false，即不保证线程获取许可的顺序。
常用方法

1. acquire()
   描述：用于获取一个许可。如果信号量的计数器大于 0，许可数减 1；如果计数器为 0，线程会被阻塞，直到有线程释放许可。
   用法：
   semaphore.acquire(); // 获取一个许可
   抛出异常：InterruptedException 如果线程在等待许可的过程中被中断。
2. release()
   描述：释放一个许可，信号量的计数器加 1。如果有线程因为获取许可而被阻塞，释放许可时会唤醒一个线程。
   用法：
   semaphore.release(); // 释放一个许可
3. availablePermits()
   描述：返回当前信号量的许可数，即信号量当前可用的资源数量。
   用法：
   int available = semaphore.availablePermits(); // 获取当前可用的许可数
4. tryAcquire()（非阻塞获取）
   描述：尝试获取一个许可。如果信号量的计数器大于 0，许可数减 1，方法返回 true。如果计数器为 0，方法立即返回 false，不阻塞线程。
   用法：
   boolean acquired = semaphore.tryAcquire(); // 非阻塞获取许可
5. tryAcquire(long timeout, TimeUnit unit)（带超时的非阻塞获取）
   描述：尝试在指定的时间内获取一个许可。如果在超时时间内获取成功，返回 true；如果超时未成功获取，则返回 false。
   用法：
   boolean acquired = semaphore.tryAcquire(100, TimeUnit.MILLISECONDS); // 100毫秒内尝试获取许可
   示例：使用 Semaphore 控制并发
6. 控制并发线程数
   假设你有一个任务需要控制最大并发数量，可以使用 Semaphore 来限制同时执行任务的线程数。

import java.util.concurrent.Semaphore;public class SemaphoreExample {private static Semaphore semaphore = new Semaphore(3);  // 最多允许3个线程同时执行public static void main(String[] args) {for (int i = 0; i < 10; i++) {new Thread(new Task(i)).start();}}static class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {try {semaphore.acquire();  // 获取许可System.out.println("Task " + taskId + " is executing.");Thread.sleep(2000);  // 模拟任务执行时间System.out.println("Task " + taskId + " finished.");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {semaphore.release();  // 释放许可}}}
}

这里创建了一个 Semaphore 对象，允许最多 3 个线程同时执行任务。如果有更多的线程，它们将被阻塞，直到其他线程释放许可。
2. 公平信号量
Semaphore semaphore = new Semaphore(1, true); // 公平模式，允许一个线程访问资源
当多个线程请求访问资源时，公平模式保证线程按请求顺序获取许可，而不公平模式则可能导致一些线程长时间无法获取许可（例如，后来的线程可能在前面的线程之前获得许可）。
应用场景
限流：可以控制一个系统在某个时间内并发访问的最大数量。例如，限制同一时刻只能有 5 个请求访问某个外部服务。
连接池：控制同时可以与外部系统建立连接的线程数。连接池中每个连接都可以视为一个资源。
并发控制：在多个线程访问共享资源时，控制同时执行的线程数量，防止过多线程争夺资源造成性能瓶颈或资源耗尽。
生产者-消费者问题：在生产者生成数据的速度和消费者处理数据的速度不一致时，信号量可以用来控制生产者和消费者之间的协作。
注意事项
公平 vs 非公平：默认情况下，Semaphore 是非公平的。在高并发环境下，公平信号量（fair=true）可能会引入一些额外的性能开销，因为它保证了线程获取资源的顺序。
死锁：和其他并发工具一样，不正确的使用信号量可能导致死锁。例如，如果一个线程在获取信号量后发生异常而没有释放信号量，可能会导致其他线程一直等待资源。
性能开销：虽然信号量是轻量级的，但是在高并发情况下频繁地获取和释放许可可能会带来一定的性能开销，尤其是在公平模式下。

Semaphore 与 ReentrantLock

Semaphore 基本能完成 ReentrantLock 的所有工作，使用方法也与之类似，通过 acquire()与release()方法来获得和释放临界资源。经实测，Semaphone.acquire()方法默认为可响应中断锁，
与 ReentrantLock.lockInterruptibly()作用效果一致，也就是说在等待临界资源的过程中可以被
Thread.interrupt()方法中断。
此外，Semaphore 也实现了可轮询的锁请求与定时锁的功能，除了方法名 tryAcquire 与 tryLock不同，其使用方法与 ReentrantLock 几乎一致。Semaphore 也提供了公平与非公平锁的机制，也可在构造函数中进行设定。
Semaphore 的锁释放操作也由手动进行，因此与 ReentrantLock 一样，为避免线程因抛出异常而无法正常释放锁的情况发生，释放锁的操作也必须在 finally 代码块中完成。
// 创建一个计数阈值为 5 的信号量对象

// 只能 5 个线程同时访问
Semaphore semp = new Semaphore(5);
try { // 申请许可
semp.acquire();
try {
// 业务逻辑} catch (Exception e) {
} finally {
// 释放许可
semp.release();
}
} catch (InterruptedException e) {
}

Semaphore常用场景

Semaphore 是 Java 中用于控制同时访问特定资源的线程数的工具。它通常用于实现并发控制，避免过多的线程同时访问共享资源，导致资源过载或系统性能下降。

1. 限制并发线程数（最常见场景）

在这个示例中，我们使用 Semaphore 来限制同时访问某个资源的线程数。假设我们有一个可以并发处理请求的服务器，但我们希望限制并发的请求数量，以避免系统过载。
代码示例：限制最大并发数

import java.util.concurrent.Semaphore;public class SemaphoreExample {// 创建信号量，最多允许 3 个线程并发执行private static Semaphore semaphore = new Semaphore(3);public static void main(String[] args) {// 启动 10 个线程模拟并发请求for (int i = 0; i < 10; i++) {new Thread(new Task(i)).start();}}static class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {try {// 获取信号量许可，最多允许 3 个线程同时执行semaphore.acquire();System.out.println("Task " + taskId + " is executing.");Thread.sleep(2000);  // 模拟任务执行时间System.out.println("Task " + taskId + " finished.");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {// 释放信号量许可semaphore.release();}}}
}

说明
创建了一个 Semaphore 对象，最大许可数为 3，即最多允许 3 个线程同时执行任务。
每个线程执行任务时，首先调用 semaphore.acquire() 获取许可。如果没有许可可用，线程会被阻塞。
任务执行完成后，调用 semaphore.release() 释放许可，允许其他被阻塞的线程获取许可。

2. 公平模式的信号量（保证按顺序访问资源）

在默认情况下，Semaphore 是非公平的，即线程获取许可的顺序是不确定的。为了保证线程按照请求的顺序来获取许可，可以使用公平模式。
代码示例：公平信号量

import java.util.concurrent.Semaphore;public class FairSemaphoreExample {// 创建公平信号量，最多允许 2 个线程并发执行private static Semaphore semaphore = new Semaphore(2, true);public static void main(String[] args) {// 启动 5 个线程模拟并发请求for (int i = 0; i < 5; i++) {new Thread(new Task(i)).start();}}static class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {try {// 获取信号量许可semaphore.acquire();System.out.println("Task " + taskId + " is executing.");Thread.sleep(2000);  // 模拟任务执行时间System.out.println("Task " + taskId + " finished.");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {// 释放信号量许可semaphore.release();}}}
}

说明
在创建 Semaphore 时，第二个参数设置为 true，表示启用公平模式。在这种模式下，信号量会保证线程按顺序（即按照线程请求的顺序）获取许可。
如果不使用公平模式，则线程获得许可的顺序可能不按请求顺序，而是依赖于操作系统的调度策略。

3. 限制数据库连接数（模拟数据库连接池）

在多线程环境下，假设多个线程需要访问数据库，但为了避免数据库过载，我们限制同一时刻只有一定数量的线程能访问数据库。这个场景很适合用 Semaphore 来模拟连接池的并发控制。
代码示例：数据库连接池

import java.util.concurrent.Semaphore;public class DatabaseConnectionPool {// 创建信号量，模拟连接池，最多允许 3 个线程同时访问数据库private static Semaphore connectionPool = new Semaphore(3);public static void main(String[] args) {// 启动 10 个线程模拟并发数据库访问for (int i = 0; i < 10; i++) {new Thread(new DatabaseTask(i)).start();}}static class DatabaseTask implements Runnable {private int taskId;public DatabaseTask(int taskId) {this.taskId = taskId;}@Overridepublic void run() {try {System.out.println("Task " + taskId + " is waiting for a database connection.");// 获取一个数据库连接（信号量许可）connectionPool.acquire();System.out.println("Task " + taskId + " is using a database connection.");Thread.sleep(2000);  // 模拟数据库操作时间System.out.println("Task " + taskId + " finished using the database connection.");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {// 释放数据库连接（释放信号量许可）connectionPool.release();}}}
}

说明
该示例模拟了一个数据库连接池，最多允许 3 个线程同时获取数据库连接（最多 3 个线程访问数据库）。
线程在获取数据库连接前会调用 connectionPool.acquire()，如果没有空闲连接，线程会被阻塞。
线程操作完数据库后，调用 connectionPool.release() 释放连接，允许其他等待的线程获取连接。

4. 限制 API 请求次数

在一些场景下，例如 API 请求的频率限制，你可能希望在一定时间内只允许有限的请求数。Semaphore 可以很好地实现这一功能。
代码示例：API 请求频率限制

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;public class ApiRateLimiter {// 创建一个信号量，最多允许每秒 2 次 API 请求private static Semaphore semaphore = new Semaphore(2);public static void main(String[] args) {// 启动 5 个线程模拟 API 请求for (int i = 0; i < 5; i++) {new Thread(new ApiRequest(i)).start();}}static class ApiRequest implements Runnable {private int requestId;public ApiRequest(int requestId) {this.requestId = requestId;}@Overridepublic void run() {try {// 尝试获取许可if (semaphore.tryAcquire(1, TimeUnit.SECONDS)) {System.out.println("API request " + requestId + " is being processed.");Thread.sleep(500);  // 模拟请求处理时间System.out.println("API request " + requestId + " finished.");} else {System.out.println("API request " + requestId + " failed due to rate limit.");}} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {// 释放许可semaphore.release();}}}
}

说明
这个示例模拟了一个简单的 API 请求频率限制，每秒最多允许 2 个请求。
线程通过 semaphore.tryAcquire(1, TimeUnit.SECONDS) 尝试获取许可，超过频率限制的请求将失败，tryAcquire() 方法在等待超过指定时间后返回 false。
总结
通过 Semaphore 可以有效地控制并发访问的数量，适用于多种场景，包括限流、数据库连接池、资源访问控制等。在使用时需要注意合理的信号量数量设置，并且避免死锁和资源泄露等问题。