guava ratelimiter限流(2)

最新推荐文章于 2021-11-23 14:42:19 发布
最新推荐文章于 2021-11-23 14:42:19 发布
阅读量2.8k 收藏 35
点赞数 8
分类专栏： 限流、分布式唯一ID 文章标签： 限流 互联网限流 ratelimiter算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hellozpc/article/details/107582771
版权

【订阅专栏合集，关注公众号，作者所有付费文章都能看(持续更新)】

  本篇是《Guava RateLimiter互联网限流实战(上)》的姊妹篇，主要介紹算法java实现。包括计数器法、滑动窗口计数法、漏斗桶算法、令牌桶算法。

文章目录

Guava ratelimiter工程概览

在这里插入图片描述

基于redis的简单计数法

新建springboot工程并引入依赖

<properties>
    <java.version>1.8</java.version>
    <spring.version>2.3.1.RELEASE</spring.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.8.0</version>
    </dependency>

    <dependency>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
        <version>5.3.2.RELEASE</version>
    </dependency>
</dependencies>

配置application.properties

server.port=8888
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=1000
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=2000

编写RedisCountLimit

基于redis的incr机制

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.time.LocalTime;
import java.util.concurrent.TimeUnit;

/**
 * 计数法限流
 */
@Component
public class RedisCountLimit {
    public static final String KEY = "ratelimit_";
    public static final int LIMIT = 10;

    @Autowired
    StringRedisTemplate redisTemplate;

    public boolean triggerLimit(String reqPath) {
        String redisKey = KEY + reqPath;
        Long count = redisTemplate.opsForValue().increment(redisKey, 1);
        System.out.println(LocalTime.now() + " " + reqPath + " " + count);
        if (count != null && count == 1) {
            redisTemplate.expire(redisKey, 60, TimeUnit.SECONDS);
        }
        //防止出现并发操作未设置超时时间的场景,这样key就是永不过期,存在风险
        if (redisTemplate.getExpire(redisKey, TimeUnit.SECONDS) == -1) {
            redisTemplate.expire(redisKey, 60, TimeUnit.SECONDS);
        }

        if (count > LIMIT) {
            System.out.println(LocalTime.now() + " " + reqPath + " count is:" + count + ",触发限流");
            return true;
        }

        return false;
    }
}

Controller层集成

import com.bigbird.ratelimit.rediscount.RedisCountLimit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

/**
 * 基于redis的计数器限流demo
 */
@RestController
public class RedisCountLimitController {
    @Autowired
    RedisCountLimit redisCountLimit;

    @RequestMapping("/rediscount")
    public String redisCount(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = redisCountLimit.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }

    @RequestMapping("/rediscount2")
    public String redisCount2(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = redisCountLimit.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }
}

运行测试

启动springboot工程，确保redis已运行，浏览器访问，f5多刷新几次

  • http://localhost:8888/rediscount
  • http://localhost:8888/rediscount2

基于redis的滑动窗口计数法

编写RedisSlidingCountLimit

通过redis的zset数据结构

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalTime;
import java.util.UUID;

/**
 * 滑动窗口计数法限流
 */
@Component
public class RedisSlidingCountLimit {
    public static final String KEY = "slidelimit_";
    public static final int LIMIT = 10;
    //限流时间间隔(秒)
    public static final int PERIOD = 60;

    @Autowired
    StringRedisTemplate redisTemplate;

    public boolean triggerLimit(String reqPath) {
        String redisKey = KEY + reqPath;

        if (redisTemplate.hasKey(redisKey)) {
            Integer count = redisTemplate.opsForZSet().rangeByScore(redisKey, System.currentTimeMillis() - PERIOD * 1000, System.currentTimeMillis()).size();
            System.out.println(count);
            if (count != null && count > LIMIT) {
                System.out.println(LocalTime.now() + " " + reqPath + " count is:" + count + ",触发限流");
                return true;
            }
        }

        long currentTime = System.currentTimeMillis();
        redisTemplate.opsForZSet().add(redisKey, UUID.randomUUID().toString(), currentTime);
        // 清除旧的访问数据,比如period=60s时,标识清除60s以前的记录
        redisTemplate.opsForZSet().removeRangeByScore(redisKey, 0, System.currentTimeMillis() - PERIOD * 1000);
        return false;
    }
}

Controller层集成

import com.bigbird.ratelimit.rediscount.RedisSlidingCountLimit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

/**
 * 基于Redis的滑动窗口计数器限流demo
 */
@RestController
public class RedisSlidingCountLimitController {
    @Autowired
    RedisSlidingCountLimit redisSlidingCountLimit;

    @RequestMapping("/slidecount")
    public String redisCount(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = redisSlidingCountLimit.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }

    @RequestMapping("/slidecount2")
    public String redisCount2(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = redisSlidingCountLimit.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }
}

运行测试

启动springboot工程，确保redis已运行，访问

  • http://localhost:8888/slidecount
  • http://localhost:8888/slidecount2

漏斗桶算法

编写LeakyBucket

import java.time.LocalTime;

/**
 * 漏斗桶算法限流
 */
public class LeakyBucket {
    /**
     * 每秒处理数量(出水速率)
     */
    private int rate;

    /**
     * 桶容量
     */
    private int capacity;

    /**
     * 当前水量
     */
    private int water;

    /**
     * 最后刷新时间
     */
    private long refreshTime;

    public LeakyBucket(int rate, int capacity) {
        this.capacity = capacity;
        this.rate = rate;
    }

    private void refreshWater() {
        long now = System.currentTimeMillis();
        water = (int) Math.max(0, water - (now - refreshTime) / 1000 * rate);
        refreshTime = now;
    }

    public synchronized boolean triggerLimit(String reqPath) {
        refreshWater();
        if (water < capacity) {
            water++;
            System.out.println(LocalTime.now() + " " + reqPath + " current capacity is:" + (capacity - water) + ",water is:" + water + ",请求成功");
            return false;
        } else {
            System.out.println(LocalTime.now() + " " + reqPath + " current capacity is:" + (capacity - water) + ",water is:" + water + ",触发限流");
            return true;
        }
    }
}

Controller层集成

import com.bigbird.ratelimit.leakybucket.LeakyBucket;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

/**
 * 漏斗桶算法限流demo
 */
@RestController
public class LeakyBucketLimitController {
    LeakyBucket bucket1 = new LeakyBucket(2, 10);
    LeakyBucket bucket2 = new LeakyBucket(2, 20);

    @RequestMapping("/leakyBucket1")
    public String leakyBucket1(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = bucket1.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }

    @RequestMapping("/leakyBucket2")
    public String leakyBucket2(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = bucket2.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }
}

运行测试

启动springboot工程，浏览器访问下列地址，连续f5多刷新测试

  • http://localhost:8888/leakyBucket1
  • http://localhost:8888/leakyBucket2

令牌桶算法(RateLimiter)

基于Guava RateLimiter实现

引入依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

编写TokenBucket

import com.google.common.util.concurrent.RateLimiter;
import java.time.LocalTime;
import java.util.concurrent.TimeUnit;

/**
 * 令牌桶算法限流
 */
public class TokenBucket {
    /**
     * qps,即每秒处理数量
     */
    private int rate;
    private RateLimiter rateLimiter;

    public TokenBucket(int rate) {
        this.rate = rate;
        this.rateLimiter = RateLimiter.create(rate);
        //在实际业务开发中，一般一种限流场景下的个体对应一个RateLimiter实例
        //比如对客户端IP限流，会创建一个 static volatile 的 Map <Ip,RateLimiter>保存各个IP的限流器
        //比如对url限流，会创建一个 static volatile 的 Map <Url,RateLimiter>保存各个Url的限流器
        //比如对商户限流，会创建一个 static volatile 的 Map <MerchantId,RateLimiter>保存各个商户的限流器
        //static volatile 修饰的变量可以保证全局可见、统一配置，实时修改限流配置后立即生效
    }

    public boolean triggerLimit(String reqPath) {
        boolean acquireRes = rateLimiter.tryAcquire(500, TimeUnit.MILLISECONDS);
        if (acquireRes) {
            System.out.println(LocalTime.now() + " " + reqPath + ",请求成功");
            return false;
        } else {
            System.out.println(LocalTime.now() + " " + reqPath + ",触发限流");
            return true;
        }
    }
}

关于volatile关键字参考《volatile关键字解析与实践》

Controller层集成

import com.bigbird.ratelimit.tokenbucket.TokenBucket;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

/**
 * 令牌桶限流算法demo
 */
@RestController
public class TokenBucketLimitController {
    /**
     * 每秒钟限速1
     */
    TokenBucket bucket1 = new TokenBucket(1);
    /**
     * 每秒钟限速2
     */
    TokenBucket bucket2 = new TokenBucket(2);

    @RequestMapping("/tokenBucket1")
    public String leakyBucket1(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = bucket1.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }

    @RequestMapping("/tokenBucket2")
    public String leakyBucket2(HttpServletRequest request) {
        String servletPath = request.getServletPath();
        boolean triggerLimit = bucket2.triggerLimit(servletPath);
        if (triggerLimit) {
            return LocalDateTime.now() + " " + servletPath + " 系统忙，稍后再试";
        } else {
            return LocalDateTime.now() + " " + servletPath + "请求成功";
        }
    }
}

运行测试

启动springboot工程，浏览器访问下列地址，连续f5多刷新测试

  • http://localhost:8888/tokenBucket1
  • http://localhost:8888/tokenBucket2

在实际业务开发中，一般一种限流场景下的个体对应一个RateLimiter实例

比如对客户端IP限流，会创建一个 static volatile 的 Map <Ip,RateLimiter>保存各个IP的限流器

比如对接口url限流，会创建一个 static volatile 的 Map <Url,RateLimiter>保存各个Url的限流器

比如对商户限流，会创建一个 static volatile 的 Map <MerchantId,RateLimiter>保存各个商户的限流器

static volatile 修饰的变量可以保证全局统一配置，实时修改限流配置后立即生效

自定义注解、aop封装限流

  上述实现方式简单粗暴，实际应用中可以封装自定义注解，并通过aop实现controller层接口自动限流拦截。废话不多说，上代码。下面的案例基于RateLimiter令牌桶。其它算法读者可以参考此例自行封装。

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

编写自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtRateLimiter {
    double permitsPerSecond();

    long timeout();
}

编写aop切面

import com.bigbird.ratelimit.annotation.ExtRateLimiter;
import com.google.common.util.concurrent.RateLimiter;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.time.LocalTime;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * 封装基于RateLimiter的限流注解
 */
@Component
@Aspect
public class RateLimiterAop {

    /**
     * 保存接口路径和限流器的对应关系
     */
    private ConcurrentHashMap<String, RateLimiter> rateLimiters = new ConcurrentHashMap();

    @Pointcut("execution(public * com.bigbird.ratelimit.controller.*.*(..))")
    public void rateLimiterAop() {
    }

    /**
     * 使用环绕通知拦截所有Controller请求
     *
     * @param proceedingJoinPoint
     * @return
     */
    @Around("rateLimiterAop()")
    public Object doBefore(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
        Method method = signature.getMethod();
        if (method == null) {
            return null;
        }

        ExtRateLimiter extRateLimiter = method.getDeclaredAnnotation(ExtRateLimiter.class);
        if (extRateLimiter == null) {
            return proceedingJoinPoint.proceed();
        }

        double permitsPerSecond = extRateLimiter.permitsPerSecond();
        long timeout = extRateLimiter.timeout();

        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String requestURI = requestAttributes.getRequest().getRequestURI();
        RateLimiter rateLimiter = rateLimiters.get(requestURI);
        if (rateLimiter == null) {
            rateLimiter = RateLimiter.create(permitsPerSecond);
            RateLimiter rateLimiterPrevious = rateLimiters.putIfAbsent(requestURI, rateLimiter);
            if (rateLimiterPrevious != null) {
                rateLimiter = rateLimiterPrevious;
            }
        }

        boolean tryAcquire = rateLimiter.tryAcquire(timeout, TimeUnit.MILLISECONDS);
        if (!tryAcquire) {
            System.out.println(LocalTime.now() + " " + requestURI + " 触发限流");
            doFallback();
            return null;
        }

        System.out.println(LocalTime.now() + " " + requestURI + " 请求成功");
        return proceedingJoinPoint.proceed();
    }

    private void doFallback() {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = requestAttributes.getResponse();
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            writer.println("系统忙，请稍后再试！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            writer.close();
        }
    }
}

Controller层集成

对要限流的接口加ExtRateLimiter 注解设置

import com.bigbird.ratelimit.annotation.ExtRateLimiter;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalTime;

/**
 * 自定义注解标识接口进行限流
 */
@RestController
public class ExtRateLimiterController {
    @RequestMapping("/extRate1")
    @ExtRateLimiter(permitsPerSecond = 0.5, timeout = 500)
    public String extRate1(HttpServletRequest request) {
        return LocalTime.now() + " " + request.getRequestURI() + "请求成功";
    }

    @RequestMapping("/extRate2")
    @ExtRateLimiter(permitsPerSecond = 2, timeout = 500)
    public String extRate2(HttpServletRequest request) {
        return LocalTime.now() + " " + request.getRequestURI() + "请求成功";
    }
}

运行测试

启动springboot工程，浏览器访问下列地址，连续f5多刷新测试

  • http://localhost:8888/extRate1
  • http://localhost:8888/extRate2

小结

  本文通俗易懂地介绍了互联网限流相关的概念与算法，并且附以Java代码实现。包括计数器法、滑动窗口计数法、漏斗桶算法、令牌桶算法。最后封装了一个自定义限流注解以及aop拦截接口限流。

代码下载地址：https://github.com/bigbirditedu/learn-ratelimit

【项目实战】限流框架介绍 - 使用Guava RateLimiter限制请求速率
本本本添哥
04-19 472
RateLimiter类使用令牌桶算法来限制请求速率。您可以使用RateLimiter类来限制每秒钟处理的请求数，或者限制每秒钟处理的字节数。
Google guava第二讲：Ratelimiter限流原理与实现
Jet_qi的博客
08-27 2424
在开发高并发系统时，有三把利器用来保护系统：**缓存、降级和限流**。限流可以认为服务降级的一种，限流通过限制请求的流量以达到保护系统的目的。 - 一般来说，系统的吞吐量是可以计算出一个阈值的，为了保证系统的稳定运行，一旦达到这个阈值，就需要限制流量并采取一些措施以完成限制流量的目的。比如：延迟处理，拒绝处理，或者部分拒绝处理等等。否则，很容易导致服务器的宕机。...
Guava RateLimiter限流原理解析
cjc000的博客
06-13 280
限流是保护高并发系统的三把利器之一，另外两个是缓存和降级。限流在很多场景中用来限制并发和请求量，比如说秒杀抢购，保护自身系统和下游系统不被巨型流量冲垮等。 限流的目的是通过对并发访问/请求进行限速或者一个时间窗口内的的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务或进行流量整形。 常用的限流方式和场景有：限制总并发数（比如数据库连接池、线程池）、限制瞬时并发数（如nginx的limit...
guava ratelimiter限流(1)
鸟哥哥的专栏
07-25 2246
guava ratelimiter 限流 原理，本文介绍guava ratelimiter互联网并发限流相关的概念与算法，包括计数器法、滑动窗口计数法、漏斗桶算法、令牌桶算法。并提供计数器法、滑动窗口计数法、漏斗桶算法、令牌桶算法的Java实现。
限流器及Guava实现分析
weixin_33736048的博客
09-02 1090
限流 限流一词常用于计算机网络之中，定义如下： In computer networks, rate limiting is used to control the rate of traffic sent or received by a network interface controller and is used to preve...
基于Redis组件之分布式RateLimiter限流
BugRoot的博客
05-18 8320
上文我们介绍了RateLimiter文章路径针对IP来限流的方式，上文的限流方案，只针对单应用情况，分布式集群下就不能使用上文的方式，分布式下的限流方案有很多种,这边展示的是Redis的封装redission框架。 可以这么讲，jdk中的juc包提供的是单机版的并发业务。那么Redisson基本是基于juc实现的分布式的业务。 一：Redission官网 我们先去Redission官网喵喵 redission官方地址 我们可以看到wiki提供了很多功能介绍， 分布式锁等，我们这篇文章主要讲限流。进入正题
Guava官方文档-RateLimiter类
java_2017_csdn的博客
09-10 1602
Guava官方文档-RateLimiter类 原文链接作者：Dimitris Andreou 译者：魏嘉鹏 校对：方腾飞 RateLimiter 从概念上来讲，速率限制器会在可配置的速率下分配许可证。如果必要的话，每个acquire()会阻塞当前线程直到许可证可用后获取该许可证。一旦获取到许可证，不需要再释放许可证。 校对注：RateLimiter使用的是一种叫令牌桶的流控算法，RateLimiter会按照一定的频率往桶里扔令牌，线程拿到令牌才能执行，比如你希望自己的应用程序QPS不要超过1...
Guava之RateLimiter限流
BugRoot的博客
05-12 3182
RateLimter是什么，我们为什么需要用到它，以物流系统作为例子：比如系统有一个物流信息查询接口，提供给第三方调用，接口暴露在公网，会出现什么问题，大致讲下如下问题： 1、大量正常用户高频访问导致服务器宕机 2、恶意用户高频访问导致服务器宕机 3、网络爬虫等等 限流常见方案： 1：Nginx限流 2：Tomcat限流 3：漏桶算法 4：令牌算法等等 这里不多介绍，只介绍下RateLimter的令牌算法。 其它的后续文章会加上。 需要引入第三方组件库 <dependency> &lt
Guava RateLimiter 实现 API 限流，为每个方法设置不同的限流
qq_39508627的博客
10-21 990
Guava提供的RateLimiter可以限制物理或逻辑资源的被访问速率，咋一听有点像java并发包下的Samephore，但是又不相同，RateLimiter控制的是速率，Samephore控制的是并发量。 RateLimiter的原理类似于令牌桶，它主要由许可发出的速率来定义，如果没有额外的配置，许可证将按每秒许可证规定的固定速度分配，许可将被平滑地分发，若请求超过permitsPerSecond则RateLimiter按照每秒 1/permitsPerSecond 的速率释放许可。 引入依赖： mav
并发编程案例：高性能限流器Guava RateLimiter
wdj0311的博客
11-23 252
Guava 是Google 开源的 Java 类库，提供了一个工具类 RateLimiter。我们先来看看 RateLimiter的使用，让你对限流有个感官的印象。假设我们有一个线程池，它每秒只能处理两个任务，如果提交的任务过快，可能导致系统不稳定，这个时候就需要用到限流。
【Guava】使用Guava的RateLimiter做限流
靡不有初，鲜克有终。
05-27 253
https://blog.csdn.net/aa1215018028/article/details/80866335
使用Guava的RateLimiter做限流
weixin_34107739的博客
06-21 349
2019独角兽企业重金招聘Python工程师标准>>> ...
限流算法之漏桶算法、令牌桶算法
weixin_34313182的博客
11-04 4161
1.限流 每个API接口都是有访问上限的,当访问频率或者并发量超过其承受范围时候,我们就必须考虑限流来保证接口的可用性或者降级可用性.即接口也需要安装上保险丝,以防止非预期的请求对系统压力过大而引起的系统瘫痪. 通常的策略就是拒绝多余的访问,或者让多余的访问排队等待服务,或者引流. 如果要准确的控制QPS,简单的做法是维护一个单位时间内的Counter,如判断单位时间已经过去,则将Count...
google的RateLimiter限流器的使用
红豆和绿豆的博客
11-12 5777
背景：A系统需要调用B，C，D系统，B，C，D系统没有能力做限流，因此需要A系统针对B，C，D系统做限流，每秒发送对象要求的请求数。可以使用下面的组件进行控制 import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import com.google.common.util.concu...
Guava RateLimiter在Web应用中的使用
热门推荐
cloud的技术积累
02-07 1万+
Google的Guava中RateLimiter实现限流
一文搞懂高频面试题之四种常用的限流算法，从算法原理到实现，再到对比分析
超悦人生
09-09 4870
看完这篇，还敢说你不会限流算法？本文对常用的限流算法计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法进行了分别介绍，并给出具体的实现。
超详细的Guava RateLimiter限流原理解析
weixin_33700350的博客
04-01 554
 限流是保护高并发系统的三把利器之一，另外两个是缓存和降级。限流在很多场景中用来限制并发和请求量，比如说秒杀抢购，保护自身系统和下游系统不被巨型流量冲垮等。  限流的目的是通过对并发访问/请求进行限速或者一个时间窗口内的的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务或进行流量整形。  常用的限流方式和场景有：限制总并发数（比如数据库连接池、线程...
请你讲讲分布式系统中的限流器一般如何实现？
hashcon
02-01 9873
限流器相关算法 一般限流器有五种算法，分别是：令牌桶，漏斗桶，固定窗口，滑动日志（指的其实是广义上的滑动窗口），滑动窗口（这里指的是滑动日志+固定窗口结合的一种算法）。 1. 令牌桶（Token bucket） 令牌桶算法用来控制一段时间内发送到网络上的数据的数目，并允许突发数据的发送。 算法大概是： 假设允许的请求速率为r次每秒，那么每过1/r秒就会向桶里面添加一个令牌。桶的最大大小是b。当一个大小为n的请求到来时，检查桶内令牌数是否足够，如果足够，令牌数减少n，请求通过。不够的话就会触发拒绝策略。 令
分布式高并发服务三种常用限流方案简介
weixin_45583158的博客
12-08 1443
服务限流场景在高并发大流量系统中，由于并发大造成服务资源不足，负载过高，进而引发致一系列问题，这里的流量一般都是突发性的，由于系统准备不足，很难短期扩容来应对 ，进行限流是最常用的手段，...
Guava RateLimiter怎么用于接口限流
最新发布
03-29
Guava RateLimiter是一个基于令牌桶算法的限流工具，可以用于接口限流。 以下是使用Guava RateLimiter实现接口限流的步骤： 1. 创建一个RateLimiter对象，设置每秒允许通过的请求数。 ``` RateLimiter rateLimiter = RateLimiter.create(10); // 每秒最多允许通过10个请求 ``` 2. 在接口方法中调用rateLimiter.acquire()方法，等待令牌桶中有足够的令牌。 ``` public void myApiMethod() { if (rateLimiter.tryAcquire()) { // 获得了令牌，可以执行接口方法 } else { // 未获得令牌，返回错误信息或者等待一段时间后重试 } } ``` 在这个例子中，如果每秒允许通过的请求数是10，那么每100毫秒会放入一个令牌，如果在接口方法被调用时没有足够的令牌，tryAcquire()方法会返回false，表示没有获得令牌，需要等待一段时间后重试。 注意，使用Guava RateLimiter进行接口限流时，需要根据实际情况设置每秒允许通过的请求数。如果设置过小，可能会导致接口响应时间过长，影响用户体验；如果设置过大，可能会导致系统负载过高，影响系统稳定性。需要根据系统的实际情况进行调整。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程猿薇茑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值