Guava的限流类使用

Guava提供了一个简单的限流工具类RateLimiter，可以用来实现令牌桶算法。下面是一个使用Guava RateLimiter实现的简单示例：

import com.google.common.util.concurrent.RateLimiter;

public class GuavaRateLimiterExample {
    public static void main(String[] args) {
        // 每秒产生5个令牌，即每秒最多允许处理5个请求
        RateLimiter rateLimiter = RateLimiter.create(5.0);

        for (int i = 0; i < 10; i++) {
            if (rateLimiter.tryAcquire()) {
                System.out.println("Request " + (i + 1) + ": Allowed");
            } else {
                System.out.println("Request " + (i + 1) + ": Rejected");
            }
        }
    }
}

在这个示例中，RateLimiter.create(5.0)表示每秒产生5个令牌，即每秒最多允许处理5个请求。tryAcquire()方法尝试获取一个令牌，如果获取成功则允许处理请求，否则拒绝请求。

除了RateLimiter之外，Guava还提供了一些其他的限流类，例如：

1. SmoothBursty： 允许一段时间内的突发请求，但是限制了请求的速率。适用于需要处理突发流量的场景。
2. SmoothWarmingUp： 在一段时间内逐渐提高请求的速率，直到达到稳定状态。适用于系统启动阶段需要逐渐增加流量的场景。
3. SmoothRateLimiter： 一个通用的限流器，可以根据具体场景和需求进行配置。提供了更灵活的控制参数。

这些类提供了不同的限流策略和行为，可以根据具体需求选择合适的限流器。

下面是Guava中SmoothBursty的简单示例：

import com.google.common.util.concurrent.SmoothBursty;

public class GuavaSmoothBurstyExample {
    public static void main(String[] args) {
        // 每秒产生5个令牌，允许突发请求，最大突发请求数为3
        SmoothBursty rateLimiter = SmoothBursty.create(5.0, 3);

        for (int i = 0; i < 10; i++) {
            if (rateLimiter.tryAcquire()) {
                System.out.println("Request " + (i + 1) + ": Allowed");
            } else {
                System.out.println("Request " + (i + 1) + ": Rejected");
            }
        }
    }
}

SmoothBursty.create(5.0, 3)表示每秒产生5个令牌，允许突发请求，最大突发请求数为3。tryAcquire()方法尝试获取一个令牌，如果获取成功则允许处理请求，否则拒绝请求。

下面是Guava中SmoothWarmingUp的简单示例：

import com.google.common.util.concurrent.SmoothWarmingUp;

import java.util.concurrent.TimeUnit;

public class GuavaSmoothWarmingUpExample {
    public static void main(String[] args) {
        // 在10秒内逐渐提高速率，最后稳定在每秒产生5个令牌
        SmoothWarmingUp rateLimiter = SmoothWarmingUp.create(10, TimeUnit.SECONDS, 5);

        for (int i = 0; i < 10; i++) {
            if (rateLimiter.tryAcquire()) {
                System.out.println("Request " + (i + 1) + ": Allowed");
            } else {
                System.out.println("Request " + (i + 1) + ": Rejected");
            }
        }
    }
}

SmoothWarmingUp.create(10, TimeUnit.SECONDS, 5)表示在10秒内逐渐提高速率，最后稳定在每秒产生5个令牌。tryAcquire()方法尝试获取一个令牌，如果获取成功则允许处理请求，否则拒绝请求。

SmoothRateLimiter是Guava中的通用限流器，可以根据具体的场景和需求进行配置。下面是一个示例：

import com.google.common.util.concurrent.SmoothRateLimiter;

import java.util.concurrent.TimeUnit;

public class GuavaSmoothRateLimiterExample {
    public static void main(String[] args) {
        // 创建一个SmoothRateLimiter，每秒产生5个令牌，且允许突发请求，最大突发请求数为3
        SmoothRateLimiter rateLimiter = SmoothRateLimiter.create(5.0, 3);

        // 或者创建一个SmoothRateLimiter，在10秒内逐渐提高速率，最后稳定在每秒产生5个令牌
        // SmoothRateLimiter rateLimiter = SmoothRateLimiter.create(10, TimeUnit.SECONDS, 5);

        for (int i = 0; i < 10; i++) {
            if (rateLimiter.tryAcquire()) {
                System.out.println("Request " + (i + 1) + ": Allowed");
            } else {
                System.out.println("Request " + (i + 1) + ": Rejected");
            }
        }
    }
}

SmoothRateLimiter提供了两种创建方式，一种是固定速率，另一种是在一定时间内逐渐提高速率。通过调用tryAcquire()方法尝试获取一个令牌，如果获取成功则允许处理请求，否则拒绝请求。