1、背景
客户端限流 PK 分布式限流
客户端限流：当应用为单点应用时，只要应用进行了限流，那么应用所依赖的各种服务也都得到了保护。
分布式限流：线上业务出于各种原因考虑，多是分布式系统，单节点的限流仅能保护自身节点，但无法保护应用依赖的各种服务，并且在进行节点扩容、缩容时也无法准确控制整个服务的请求限制
网关层限流
服务网关，作为整个分布式链路中的第一道关卡，承接了所有用户来访请求。我们在网关层进行限流，就可以达到了整体限流的目的了。目前，主流的网关层有以软件为代表的Nginx，还有Spring Cloud中的Gateway和Zuul这类网关层组件，也有以硬件为代表的F5。
限流组件
目前也有一些开源组件提供了限流的功能，比如Sentinel就是一个不错的选择。Sentinel是阿里出品的开源组件，并且包含在了Spring Cloud Alibaba组件库中。Hystrix也具有限流的功能。
中间件限流
将限流信息存储在分布式环境中某个中间件里（比如Redis缓存），每个组件都可以从这里获取到当前时刻的流量统计，从而决定是拒绝服务还是放行流量。
2、客户端应用案例
Guava是一个客户端组件，在其多线程模块下提供了以RateLimiter为首的几个限流支持类。它只能对“当前”服务进行限流，即它不属于分布式限流的解决方案。
@RestController
@RequestMapping("/guava")
@Slf4j
public class GuavaLimitController {
private static final Integer RATE_LIMIT = 10;
RateLimiter rateLimiter = RateLimiter.create(RATE_LIMIT);
@GetMapping("/try_require_rate_limit")
public String hello() {
boolean limit = false;
try {
limit = rateLimiter.tryAcquire();
} catch (Exception e) {
log.error("limit error", e);
}
if (limit) {
return "hello guava rate limit success...";
}
throw new RuntimeException("hello guava rate limit fall...");
}
@GetMapping("/acquire_rate_limit")
public String hello2() {
double acquireTimeGap = rateLimiter.acquire();
return "hello guava rate limit success, acquireTimeGap: " + acquireTimeGap;
}
}3、Jmeter测试效果
Jmeter将在10秒内逐渐启动30个线程进行并发测试，每个线程执行测试计划20次，共20 * 30 = 600次。
3.1 非阻塞限流
3.2 阻塞限流
说明：
在10s的600次请求下（QPS约为60）
阻塞请求出现20%概率请求因为获取不到令牌而被限流
非阻塞请求则因为阻塞超时而失败，大部分请求都会阻塞2s左右，然后根据获取到令牌情况成功或者失败
由上可以得出Guava客户端限流，acquire与tryAcquire确实发挥了不同效果的作用。
3.3 源码分析
轻量级锁：（参考：JVM的知识点-对象头ObjectHeader，超链接）
ObjectHeader是和对象自身定义数据无关的额外存储成本，也是JVM实现轻量级锁和偏向锁的关键。
（1）tryAcquire源码
public boolean tryAcquire() {
//【1】
return tryAcquire(1, 0, MICROSECONDS);
}
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) {
long timeoutMicros = max(unit.toMicros(timeout), 0);
// 【2】
checkPermits(permits);
long microsToWait;
// 【3】锁：线程安全下，执行申请令牌的操作
synchronized (mutex()) {
long nowMicros = stopwatch.readMicros();
// 【4】判断是否可以获取到令牌
if (!canAcquire(nowMicros, timeoutMicros)) {
// 【5】不能获取到，则直接返回false
return false;
} else {
//【6】能获取到，则取出令牌并设置 下次令牌发布时间
microsToWait = reserveAndGetWaitLength(permits, nowMicros);
}
}
// 【9】线程中断microsToWait时间
stopwatch.sleepMicrosUninterruptibly(microsToWait);
return true;
}
// 获取对象头作为锁对象
private Object mutex() {
Object mutex = mutexDoNotUseDirectly;
if (mutex == null) {
synchronized (this) {
mutex = mutexDoNotUseDirectly;
if (mutex == null) {
mutexDoNotUseDirectly = mutex = new Object();
}
}
}
return mutex;
}
// 【4】是否可以获取令牌
private boolean canAcquire(long nowMicros, long timeoutMicros) {
// now当前时间，timeoutMicros为0，那么这里就是比较上次设置好的令牌发布时间 和 当前时间的大小而已
// nextFreeTicketMicros > nowMicros：返回false，还不到获取令牌时机
// nextFreeTicketMicros < nowMicros：返回true，已经过了，可以获取令牌时机
return queryEarliestAvailable(nowMicros) - timeoutMicros <= nowMicros;
}
final long reserveAndGetWaitLength(int permits, long nowMicros) {
//【7】获取最早的令牌发布时间
long momentAvailable = reserveEarliestAvailable(permits, nowMicros);
// 【8】如果<0，说明当下时刻有令牌可获得；否则>0，说明还需要等待差值（momentAvailable - nowMicros）
return max(momentAvailable - nowMicros, 0);
}
private static void checkPermits(int permits) {
checkArgument(permits > 0, "Requested permits (%s) must be positive", permits);
}
//获取最早的令牌发布时间
@Override
final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
//调用resync(nowMicros)方法，同步限流器的状态。
resync(nowMicros);
//初始化returnValue为nextFreeTicketMicros，表示当前最早可用的许可时间。
long returnValue = nextFreeTicketMicros;
//计算storedPermitsToSpend，即从已存储的许可中可以使用的许可数量。
//这是所需许可数量（requiredPermits）和当前已存储许可数量（this.storedPermits）中的较小值。
double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
//计算freshPermits，即还需要获取的新许可数量。
//这是所需许可数量（requiredPermits）减去已存储许可数量（storedPermitsToSpend）。
double freshPermits = requiredPermits - storedPermitsToSpend;
// 计算waitMicros，即需要等待的时间。
//这是已存储许可的等待时间（通过调用storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)计算）加上新许可的等待时间（通过将freshPermits乘以稳定间隔时间（stableIntervalMicros）计算）。
long waitMicros =
storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
+ (long) (freshPermits * stableIntervalMicros);
//更新nextFreeTicketMicros，将其增加waitMicros，表示预留许可后的最早可用时间。
this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);
//更新this.storedPermits，减去已使用的许可数量（storedPermitsToSpend）。
this.storedPermits -= storedPermitsToSpend;
//返回returnValue，即预留许可的最早可用时间。
return returnValue;
}【1】申请一个令牌，并且是非阻塞立刻返回结果
【2】检查申请的令牌数是否为正数，否则抛异常
【3】mutex()方法代码是一个双重检查锁定（Double-Checked Locking）模式的实现，用于确保
mutexDoNotUseDirectly对象只被初始化一次。这种模式在多线程环境下非常有用，因为它可以减少同步的开销。【4】是否可以获取令牌：比较上次设置好的令牌发布时间 和 当前时间的大小而已
nextFreeTicketMicros > nowMicros：返回false，还不到获取令牌时机
nextFreeTicketMicros < nowMicros：返回true，已经过了，可以获取令牌时机
判断能否获取令牌
【7】获取最早的令牌发布时间，其核心算法是reserveEarliestAvailable
【8】如果<0，说明当下时刻有令牌可获得；否则>0，说明还需要等待差值（momentAvailable - nowMicros）
【5】不能获取到，则直接返回false（这是tryRequire和require的区别！！）
【6】能获取到，则取出令牌并设置 下次令牌发布时间
【9】线程中断microsToWait时间，由于上面的第【4】步骤canAcquire判断为true，那么能走到第【9】步骤，已经说明是不用等的了。
没到领牌时间就等一下
到了就直接返回不中断；
（2）acquire源码
public double acquire() {
return acquire(1);
}
public double acquire(int permits) {
// 【1】校验令牌需要多久可以获取到
long microsToWait = reserve(permits);
// 【2】此处将会阻塞
stopwatch.sleepMicrosUninterruptibly(microsToWait);
return 1.0 * microsToWait / SECONDS.toMicros(1L);
}
final long reserve(int permits) {
checkPermits(permits);
// 【3】加锁
synchronized (mutex()) {
return reserveAndGetWaitLength(permits, stopwatch.readMicros());
}
}
final long reserveAndGetWaitLength(int permits, long nowMicros) {
// 校验当前时间和下次分发令牌时间
long momentAvailable = reserveEarliestAvailable(permits, nowMicros);
return max(momentAvailable - nowMicros, 0);
}
final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
resync(nowMicros);
long returnValue = nextFreeTicketMicros;
double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
double freshPermits = requiredPermits - storedPermitsToSpend;
long waitMicros =
storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
+ (long) (freshPermits * stableIntervalMicros);
this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);
this.storedPermits -= storedPermitsToSpend;
return returnValue;
}
/** 阻塞逻辑 **/
abstract static class SleepingStopwatch {
protected SleepingStopwatch() {
}
protected abstract long readMicros();
protected abstract void sleepMicrosUninterruptibly(long var1);
public static SleepingStopwatch createFromSystemTimer() {
return new SleepingStopwatch() {
final Stopwatch stopwatch = Stopwatch.createStarted();
protected long readMicros() {
return this.stopwatch.elapsed(TimeUnit.MICROSECONDS);
}
protected void sleepMicrosUninterruptibly(long micros) {
if (micros > 0L) {
//Thread.currentThread().interrupt()是Java中用于中断当前线程的方法。当一个线程被中断时，它的中断状态将被设置为true。中断是一种协作机制，它允许一个线程通知另一个线程某个条件已经发生，从而允许接收中断的线程采取适当的行动。
Uninterruptibles.sleepUninterruptibly(micros, TimeUnit.MICROSECONDS);
}
}
};
}
}源码解析：
acquire的逻辑基本等于tryAcquire，区别只在于acquire少了一个提前返回的操作（见tryAcquire源码的第【5】步骤）
其余的方法源码的逻辑，是跟tryAcquire一样的，此处不再赘述
总结：acquire与tryAcquire
acquire() 和 tryAcquire() 是 RateLimiter 类中的两个主要方法，它们的区别如下：
acquire() 方法：
当调用
acquire()方法时，如果当前请求速率未超过限制，则请求会被立即处理，并且方法会立即返回。如果当前请求速率超过了限制，
acquire()方法会使当前线程阻塞，直到有可用的请求配额为止。这意味着，如果请求速率超过了限制，线程将等待直到可以继续执行。
tryAcquire() 方法：
当调用
tryAcquire()方法时，如果当前请求速率未超过限制，则请求会被立即处理，并且方法会立即返回true。如果当前请求速率超过了限制，
tryAcquire()方法不会阻塞当前线程，而是立即返回false。这意味着，如果请求速率超过了限制，线程将立即知道无法继续执行，并可以根据需要采取其他措施（例如重试、记录日志等）。
4、总结
总结一下，当使用客户端限流时，两种方法：acquire() 和 tryAcquire() 的主要区别在于是否阻塞当前线程。acquire() 会阻塞线程直到有可用的请求配额，而 tryAcquire() 不会阻塞线程，而是立即返回结果。
在实际应用中，我们可以根据需求和场景选择合适的方法。
扫一扫
922
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
