JAVA使用Semaphore限流的正确方式与常见错误用法分析 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java Semaphore 限流：正确姿势与常见误区

大家好，今天我们来聊聊Java并发编程中一个非常重要的工具：Semaphore（信号量），以及如何正确利用它来实现限流，同时避开一些常见的误区。限流是保证系统稳定性的重要手段，它可以防止突发流量压垮系统，保护关键资源。

什么是 Semaphore？

Semaphore本质上是一个计数器，它维护着一定数量的“许可”（permits）。线程可以通过acquire()方法获取一个许可，如果许可数大于0，则线程获得许可并继续执行；如果许可数为0，则线程进入阻塞状态，直到有其他线程释放许可。线程可以通过release()方法释放一个许可，释放后许可数增加，如果有等待的线程，则会唤醒其中一个线程。

可以把Semaphore想象成停车场。许可数相当于停车位数量。线程调用acquire()相当于车辆进入停车场，如果还有空位（许可数>0），则车辆进入；如果没有空位（许可数=0），则车辆需要在停车场外等待。线程调用release()相当于车辆驶出停车场，释放一个停车位。

Semaphore 的基本用法

Semaphore提供了两种主要的获取许可的方法：

acquire(): 阻塞式获取许可。线程会一直等待直到获取到许可。
tryAcquire(): 非阻塞式获取许可。尝试获取许可，如果立即可以获取到则返回true，否则返回false，线程不会阻塞。tryAcquire(long timeout, TimeUnit unit)还可以设置超时时间，如果在指定时间内获取不到许可，则返回false。

以及一个释放许可的方法：

release(): 释放一个许可。

下面是一个简单的Semaphore使用示例：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    private static final int PERMITS = 3; // 许可数量
    private static final Semaphore semaphore = new Semaphore(PERMITS);

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " trying to acquire permit...");
                    semaphore.acquire(); // 获取许可
                    System.out.println(Thread.currentThread().getName() + " acquired permit, processing...");
                    Thread.sleep(2000); // 模拟处理业务
                    System.out.println(Thread.currentThread().getName() + " releasing permit...");
                    semaphore.release(); // 释放许可
                    System.out.println(Thread.currentThread().getName() + " released permit.");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, "Thread-" + i).start();
        }
    }
}

在这个例子中，我们创建了一个拥有3个许可的Semaphore。5个线程尝试获取许可，只有3个线程能够立即获取到，另外2个线程会被阻塞，直到有线程释放许可。

使用 Semaphore 实现限流

Semaphore 最常见的应用场景就是限流。通过控制Semaphore的许可数量，可以限制同时访问某个资源的线程数量，从而达到限流的目的。

下面是一个简单的限流器实现：

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

public class RateLimiter {

    private final Semaphore semaphore;
    private final int permits;

    public RateLimiter(int permits) {
        this.permits = permits;
        this.semaphore = new Semaphore(permits);
    }

    public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
        return semaphore.tryAcquire(timeout, unit);
    }

    public void release() {
        semaphore.release();
    }

    public int getAvailablePermits() {
        return semaphore.availablePermits();
    }

    public static void main(String[] args) throws InterruptedException {
        RateLimiter rateLimiter = new RateLimiter(2); // 限制并发数为2

        for (int i = 0; i < 5; i++) {
            final int taskNumber = i;
            new Thread(() -> {
                try {
                    if (rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("Task " + taskNumber + " started at " + System.currentTimeMillis() / 1000 + " - Available permits: " + rateLimiter.getAvailablePermits());
                            Thread.sleep(2000); // 模拟执行任务
                            System.out.println("Task " + taskNumber + " completed at " + System.currentTimeMillis() / 1000);
                        } finally {
                            rateLimiter.release();
                        }
                    } else {
                        System.out.println("Task " + taskNumber + " rejected due to rate limiting at " + System.currentTimeMillis() / 1000);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
            Thread.sleep(500); // 快速启动多个任务
        }
    }
}

在这个例子中，我们创建了一个并发数为2的RateLimiter。每个线程尝试在1秒内获取许可，如果获取成功则执行任务，否则被拒绝。

Semaphore 常见错误用法及分析

虽然Semaphore使用起来比较简单，但也容易出现一些常见的错误用法，导致限流失效或者出现死锁等问题。

错误用法	描述	影响	解决方法
忘记释放许可 (release)	线程获取许可后，在某些情况下（例如发生异常）没有释放许可。	导致许可数减少，最终所有线程都阻塞，系统无法继续处理请求。	使用 `try-finally` 块来确保无论是否发生异常，都能释放许可。
过度释放许可 (release过多)	线程释放了超过其获取的许可数量。	导致许可数增加，超出预期范围，限流失效。	仔细检查代码，确保 `release()` 方法只在获取许可后调用，并且调用的次数与获取的次数一致。
多个线程同时获取大量许可	多个线程同时调用 `acquire(n)` 方法，尝试获取大量的许可。	导致资源竞争激烈，性能下降。	尽量避免单个线程获取大量许可，可以考虑将大的任务分解成小的任务，每个任务只需要少量许可。
在错误的场景使用 Semaphore	将 Semaphore 用于不适合的场景，例如用于控制单个线程的执行顺序，或者用于实现简单的互斥锁。	可能导致代码复杂性增加，性能下降，或者出现难以调试的bug。	仔细评估场景，选择最适合的并发工具。如果需要控制单个线程的执行顺序，可以使用 `CountDownLatch` 或 `CyclicBarrier`。如果需要实现互斥锁，可以使用 `ReentrantLock`。
使用不公平的 Semaphore	使用默认构造函数创建 Semaphore，导致线程获取许可的顺序不确定，可能会出现饥饿现象。	某些线程可能长时间无法获取到许可，导致响应时间变长。	使用 `Semaphore(int permits, boolean fair)` 构造函数，并将 `fair` 设置为 `true`，创建一个公平的 Semaphore。公平的 Semaphore 会按照线程请求的顺序分配许可，可以避免饥饿现象。但是，公平的 Semaphore 的性能通常比不公平的 Semaphore 略低。
并发量超过许可数但未处理拒绝情况	当并发请求超过Semaphore的许可数时，`tryAcquire()`返回false，但程序没有正确处理这种情况，例如没有重试机制，或者只是简单地忽略了失败的情况。	导致部分请求被丢弃，影响用户体验。	确保在 `tryAcquire()` 返回 `false` 时，进行适当的处理。例如，可以实现重试机制，或者返回错误信息给用户。
错误的初始化许可数量	初始化Semaphore的许可数量不合理，例如设置的许可数量过大或者过小。	许可数量过大可能导致限流失效，许可数量过小可能导致系统资源利用率过低。	根据实际情况，选择合适的许可数量。可以通过性能测试来确定最佳的许可数量。
没有考虑异常情况下的释放	在acquire()和release()之间，如果发生了RuntimeException，而没有捕获处理，会导致release()方法没有执行，从而造成死锁，影响系统的可用性。	如果在acquire()和release()之间发生RuntimeException，而release()方法没有执行，会导致其他线程一直等待，造成死锁，影响系统的可用性。	使用try…finally结构保证release()方法一定会被执行，即使在acquire()和release()之间发生RuntimeException，也能保证release()方法会被执行，从而避免死锁。

下面针对“忘记释放许可”这个常见错误，提供一个更具体的示例和解决方案：

import java.util.concurrent.Semaphore;

public class SemaphoreExampleCorrected {

    private static final int PERMITS = 1;
    private static final Semaphore semaphore = new Semaphore(PERMITS);

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " trying to acquire permit...");
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " acquired permit, processing...");
                    // Simulate an exception occurring during processing
                    if (Math.random() < 0.5) {
                        throw new RuntimeException("Simulated exception!");
                    }
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + " finished processing.");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (RuntimeException e) {
                    System.err.println(Thread.currentThread().getName() + " encountered an exception: " + e.getMessage());
                } finally {
                    System.out.println(Thread.currentThread().getName() + " releasing permit...");
                    semaphore.release(); // Ensure permit is always released
                    System.out.println(Thread.currentThread().getName() + " released permit.");
                }
            }, "Thread-" + i).start();
        }
    }
}

在这个修正后的例子中，我们使用了 try-finally 块来确保 release() 方法始终被调用，即使在 try 块中发生了异常。这样可以避免因异常导致许可无法释放而造成的死锁。

更高级的限流策略

除了简单的基于Semaphore的限流，还有一些更高级的限流策略，例如：

令牌桶算法 (Token Bucket)：以恒定的速率向令牌桶中添加令牌，只有拿到令牌的请求才能被处理。
漏桶算法 (Leaky Bucket)：将请求放入漏桶中，漏桶以恒定的速率漏出请求。
滑动窗口算法 (Sliding Window)：维护一个时间窗口，记录窗口内的请求数量，如果请求数量超过阈值，则拒绝新的请求。

这些算法通常需要更复杂的实现，但可以提供更灵活和精确的限流控制。可以使用 Guava 的 RateLimiter 类来实现令牌桶算法。

选择合适的限流策略

选择合适的限流策略需要考虑以下因素：

业务需求：不同的业务场景对限流的要求不同。例如，对于高并发的API接口，可能需要使用更严格的限流策略。
系统资源：限流的目的是保护系统资源，因此需要根据系统资源的实际情况来选择合适的限流阈值。
性能影响：限流本身也会带来一定的性能开销，因此需要在限流的严格性和性能之间进行权衡。
复杂性：不同的限流策略的实现复杂度不同，需要根据团队的技术能力来选择合适的策略。

总结

Semaphore是一个强大的并发工具，可以用于实现限流、资源控制等功能。但是，在使用Semaphore时需要注意一些常见的错误用法，例如忘记释放许可、过度释放许可等。通过选择合适的限流策略，并正确使用Semaphore，可以有效地保护系统资源，提高系统的稳定性和可用性。

要点回顾

Semaphore 维护一组许可，线程可以获取和释放许可。
Semaphore 可用于实现限流，防止系统被过载。
正确使用 Semaphore 的关键在于确保许可总是被正确释放，避免死锁和资源耗尽。