常用的限流算法有漏桶算法和令牌桶算法，guava的RateLimiter使用的是令牌桶算法，也就是以固定的频率向桶中放入令牌，例如一秒钟10枚令牌，实际业务在每次响应请求之前都从桶中获取令牌，只有取到令牌的请求才会被成功响应，获取的方式有两种：阻塞等待令牌或者取不到立即返回失败，下图来自网上：

Guava提供的RateLimiter可以限制物理或逻辑资源的被访问速率，有点与java并发包下的Samephore类似，但是又不相同，RateLimiter控制的是速率，Samephore控制的是并发量。RateLimiter的原理类似于令牌桶，它主要由许可发出的速率来定义，如果没有额外的配置，许可证将按每秒许可证规定的固定速度分配，许可将被平滑地分发，若请求超过permitsPerSecond则RateLimiter按照每秒 1/permitsPerSecond 的速率释放许可。

RateLimiter方法摘要

方法名称	作用
acquire()	从RateLimiter获取一个许可，该方法会被阻塞直到获取到请求
acquire(int permits)	从RateLimiter获取指定许可数，该方法会被阻塞直到获取到请求
create(double permitsPerSecond	根据指定的稳定吞吐率创建RateLimiter，这里的吞吐率是指每秒多少许可数（通常是指QPS，每秒多少查询）
create(double permitsPerSecond, long warmupPeriod, TimeUnit unit)	根据指定的稳定吞吐率和预热期来创建RateLimiter，这里的吞吐率是指每秒多少许可数（通常是指QPS，每秒多少个请求量），在这段预热时间内，RateLimiter每秒分配的许可数会平稳地增长直到预热期结束时达到其最大速率。（只要存在足够请求数来使其饱和）
getRate()	返回RateLimiter 配置中的稳定速率，该速率单位是每秒多少许可数
setRate(double permitsPerSecond)	更新RateLimite的稳定速率，参数permitsPerSecond 由构造RateLimiter的工厂方法提供。
toString()	返回对象的字符表现形式
tryAcquire()	从RateLimiter 获取许可数，如果该许可数可以在无延迟下的情况下立即获取得到的话
tryAcquire(int permits, long timeout, TimeUnit unit)	从RateLimiter 获取指定许可数如果该许可数可以在不超过timeout的时间内获取得到的话，或者如果无法在timeout 过期之前获取得到许可数的话，那么立即返回false （无需等待）
tryAcquire(long timeout, TimeUnit unit)	从RateLimiter 获取许可如果该许可可以在不超过timeout的时间内获取得到的话，或者如果无法在timeout 过期之前获取得到许可的话，那么立即返回false（无需等待）

案例

项目集成：

<dependency>
   <groupId>com.google.guava</groupId>
   <artifactId>guava</artifactId>
   <version>23.0</version>
</dependency>

案例：

public class Test {
    public static void main(String[] args) {
        String start = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        RateLimiter limiter = RateLimiter.create(1.0); // 这里的1表示每秒允许处理的量为1个
        for (int i = 1; i <= 10; i++) {
            limiter.acquire();// 请求RateLimiter, 超过permits会被阻塞
            System.out.println("call execute.." + i);
        }
        String end = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("start time:" + start);
        System.out.println("end time:" + end);
    }
}

执行结果：

总结：

可以看到，我假定了每秒处理请求的速率为1个，现在我有10个任务要处理，那么RateLimiter就很好的实现了控制速率，总共10个任务，需要9次获取许可，所以最后10个任务的消耗时间为9s左右

项目实例一

@Service
public class GuavaRateLimiterService {
    /**
     * 每秒控制5个许可
     */
    RateLimiter rateLimiter = RateLimiter.create(5.0);
    /**
     * @Description获取令牌
     * @Param
     * @Return
     * @Exception
     * @Author  yaoyonghao
     * @Date   2020/6/1 10:54
     */
    public boolean tryAcquire(){
        return   rateLimiter.tryAcquire();
    }
}


@RestController
public class TestController extends BaseController {
    @Autowired
    private GuavaRateLimiterService rateLimiterService;
    @ResponseBody
    @RequestMapping("/ratelimiter")
    public String testRateLimiter() {
        if (rateLimiterService.tryAcquire()) {
            return returnMsgResult(ErrorConstantsCode.SUCCESS, "成功获取许可");
        } else {
            return returnMsgResult(ErrorConstantsCode.ERROR, "未获取到许可");
        }
    }
}

通过postman并发测试结果发现：可以发现，10个并发访问总是只有6个能获取到许可，结论就是能获取到RateLimiter.create(n)中n+1个许可

项目实例二

如果像上边使用不够灵活，如果换成自定义注解+切面的方式实现的话，会优雅的多

自定义注解

@Inherited
@Documented
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimitAspect {
}

自定义切面

@Component
@Scope
@Aspect
public class RateLimitAop { 
    @Autowired
    private HttpServletResponse response; 
    private RateLimiter rateLimiter = RateLimiter.create(5.0); //比如说，我这里设置"并发数"为5
 
    @Pointcut("@annotation(com.simons.cn.springbootdemo.aspect.RateLimitAspect)")
    public void serviceLimit() { 
    }
 
    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Boolean flag = rateLimiter.tryAcquire();
        Object obj = null;
        try {
            if (flag) {
                obj = joinPoint.proceed();
            }else{
                String result = JSONObject.fromObject(ResultUtil.success1(100, "failure")).toString();
                output(response, result);
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("flag=" + flag + ",obj=" + obj);
        return obj;
    }
    
    public void output(HttpServletResponse response, String msg) throws IOException {
        response.setContentType("application/json;charset=UTF-8");
        ServletOutputStream outputStream = null;
        try {
            outputStream = response.getOutputStream();
            outputStream.write(msg.getBytes("UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            outputStream.flush();
            outputStream.close();
        }
    }
}

@RestController
public class TestController extends BaseController {
    @Autowired
    private GuavaRateLimiterService rateLimiterService;
    
    @RateLimitAspect         //可以非常方便的通过这个注解来实现限流
    @ResponseBody
    @RequestMapping("/ratelimiter")
    public String testRateLimiter() {
        if (rateLimiterService.tryAcquire()) {
            return returnMsgResult(ErrorConstantsCode.SUCCESS, "成功获取许可");
        } else {
            return returnMsgResult(ErrorConstantsCode.ERROR, "未获取到许可");
        }
    }
}

这是我得微信公众号：程序猿微刊 更多文章请关注微信公众号