接口限流——令牌桶算法

最新推荐文章于 2024-08-20 23:00:00 发布
最新推荐文章于 2024-08-20 23:00:00 发布
阅读量763 收藏 2
点赞数
分类专栏： 接口安全 文章标签： spring boot redis 限流 令牌桶 lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28038487/article/details/100013705
版权

接口限流——令牌桶算法

简介：

在网络中传输数据时，为了防止网络拥塞，需限制流出网络的流量，使流量以比较均匀的速度向外发送。令牌桶算法就实现了这个功能，可控制发送到网络上数据的数目，并允许突发数据的发送。

令牌桶算法是网络流量整形（Traffic Shaping）和速率限制（Rate Limiting）中最常使用的一种算法。典型情况下，令牌桶算法用来控制发送到网络上的数据的数目，并允许突发数据的发送。

大小固定的令牌桶可自行以恒定的速率源源不断地产生令牌。如果令牌不被消耗，或者被消耗的速度小于产生的速度，令牌就会不断地增多，直到把桶填满。后面再产生的令牌就会从桶中溢出。最后桶中可以保存的最大令牌数永远不会超过桶的大小。

传送到令牌桶的数据包需要消耗令牌。不同大小的数据包，消耗的令牌数量不一样。

令牌桶这种控制机制基于令牌桶中是否存在令牌来指示什么时候可以发送流量。令牌桶中的每一个令牌都代表一个字节。如果令牌桶中存在令牌，则允许发送流量；而如果令牌桶中不存在令牌，则不允许发送流量。因此，如果突发门限被合理地配置并且令牌桶中有足够的令牌，那么流量就可以以峰值速率发送。

令牌桶算法的基本过程如下：

假如用户配置的平均发送速率为r，则每隔1/r秒一个令牌被加入到桶中；

假设桶最多可以存发b个令牌。如果令牌到达时令牌桶已经满了，那么这个令牌会被丢弃；

当一个n个字节的数据包到达时，就从令牌桶中删除n个令牌，并且数据包被发送到网络；

如果令牌桶中少于n个令牌，那么不会删除令牌，并且认为这个数据包在流量限制之外；

算法允许最长b个字节的突发，但从长期运行结果看，数据包的速率被限制成常量r。对于在流量限制外的数据包可以以不同的方式处理：

它们可以被丢弃；

它们可以排放在队列中以便当令牌桶中累积了足够多的令牌时再传输；

它们可以继续发送，但需要做特殊标记，网络过载的时候将这些特殊标记的包丢弃。

注意：令牌桶算法不能与另外一种常见算法“漏桶算法（Leaky Bucket）”相混淆。这两种算法的主要区别在于“漏桶算法”能够强行限制数据的传输速率，而“令牌桶算法”在能够限制数据的平均传输速率外，还允许某种程度的突发传输。在“令牌桶算法”中，只要令牌桶中存在令牌，那么就允许突发地传输数据直到达到用户配置的门限，因此它适合于具有突发特性的流量。

示意图

示意图

spring boot 结合 redis 结合 lua 实现

pom 引入相关依赖

<properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

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

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

    <dependency>
      <groupId>cn.texous.demo</groupId>
      <artifactId>demo-common-util</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

配置 redis

package cn.texous.demo.dnw.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;

/**
 * Created by admin on 2017-11-21.
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * redis模板操作类,类似于jdbcTemplate的一个类;
     * 虽然CacheManager也能获取到Cache对象，但是操作起来没有那么灵活；*
     * 这里在扩展下：RedisTemplate这个类不见得很好操作，我们可以在进行扩展一个我们
     * 自己的缓存类，比如：RedisStorage类;
     *
     * @param factory : 通过Spring进行注入，参数在application.properties进行配置；
     * @return
     */
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(factory);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(stringRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisCacheConfiguration.disableCachingNullValues();
        RedisSerializationContext.SerializationPair pair = RedisSerializationContext.SerializationPair.fromSerializer(stringRedisSerializer);
        redisCacheConfiguration.serializeKeysWith(pair);
        redisCacheConfiguration.serializeValuesWith(pair);
        return RedisCacheManager.builder(factory).cacheDefaults(redisCacheConfiguration).build();
    }

    @Bean("ratelimitLua")
    public DefaultRedisScript getRedisScript() {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setLocation(new ClassPathResource("lua/tokenBucketRatelimit.lua"));
        redisScript.setResultType(java.lang.Long.class);
        return redisScript;
    }
    @Bean("ratelimitInitLua")
    public DefaultRedisScript getInitRedisScript() {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setLocation(new ClassPathResource("lua/tokenBucketRatelimitInit.lua"));
        redisScript.setResultType(java.lang.Long.class);
        return redisScript;
    }

    @Bean("ratelimitByIdLua")
    public DefaultRedisScript getLimitByIdRedisScript() {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setLocation(new ClassPathResource("lua/counterRatelimit.lua"));
        redisScript.setResultType(java.lang.Long.class);
        return redisScript;
    }

}

限流工具类编写

package cn.texous.demo.dnw.utils;

import cn.texous.demo.dnw.common.constant.RedisKeyEnum;
import cn.texous.demo.dnw.common.constant.TokenEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Collections;

@Component
public class RateLimitClient {

    @Autowired
    StringRedisTemplate stringRedisTemplate;
    @Qualifier("ratelimitLua")
    @Resource
    RedisScript<Long> ratelimitLua;

    @Qualifier("ratelimitInitLua")
    @Resource
    RedisScript<Long> ratelimitInitLua;

    @Qualifier("ratelimitByIdLua")
    @Resource
    RedisScript<Long> ratelimitByIdLua;

    public TokenEnum initToken(String key){
        TokenEnum token = TokenEnum.SUCCESS;
        Long currMillSecond = stringRedisTemplate.execute(
                (RedisCallback<Long>) redisConnection -> redisConnection.time()
        );
        /**
         * last_mill_second 最后时间毫秒
         * curr_permits 当前可用的令牌
         * max_burst 令牌桶最大值
         * rate 每秒生成几个令牌
         * app 应用
         *
         * redis.pcall("HMSET",KEYS[1],
         "last_mill_second",ARGV[1],
         "curr_permits",ARGV[2],
         "max_burst",ARGV[3],
         "rate",ARGV[4],
         "app",ARGV[5])
         */
        Long accquire = stringRedisTemplate.execute(ratelimitInitLua,
                Collections.singletonList(getKey(key)), currMillSecond.toString(), "100", "100000", "10", "skynet");
        if (accquire == 1) {
            token = TokenEnum.SUCCESS;
        } else if (accquire == 0) {
            token = TokenEnum.SUCCESS;
        } else {
            token = TokenEnum.FAILED;
        }
        return token;
    }

    public Long accquireTokenCounter(String ip) {
        return stringRedisTemplate.execute(ratelimitByIdLua,
                Collections.singletonList(ip), "10", "1");
    }

    /**
     * 获得key操作
     *
     * @param key
     * @return
     */
    public TokenEnum accquireToken(String key) {
        return accquireToken(key, 1);
    }

    public TokenEnum accquireToken(String key, Integer permits) {
        TokenEnum token = TokenEnum.SUCCESS;
        Long currMillSecond = stringRedisTemplate.execute(
                (RedisCallback<Long>) redisConnection -> redisConnection.time()
        );

        Long accquire = stringRedisTemplate.execute(ratelimitLua,
                Collections.singletonList(getKey(key)), permits.toString(), currMillSecond.toString());
        if (accquire == 1) {
            token = TokenEnum.SUCCESS;
        } else {
            token = TokenEnum.FAILED;
        }
        return token;
    }

    public boolean exists(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    public boolean hexists(String key, String field) {
        return stringRedisTemplate.opsForHash().hasKey(key, field);
    }

    public String getKey(String key) {
        return RedisKeyEnum.RATELIMIT_KEY_PREFIX.getKey() + key;
    }

}

相关常量类

package cn.texous.demo.dnw.common.constant;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * insert description here
 *
 * @author Showa.L
 * @since 2019/8/21 16:41
 */
@Getter
@AllArgsConstructor
public enum RedisKeyEnum {

    RATELIMIT_KEY_PREFIX("ratelimit:", "限流key前缀");

    private String key;
    private String desc;

}


package cn.texous.demo.dnw.common.constant;

/**
 * insert description here
 *
 * @author Showa.L
 * @since 2019/8/21 16:43
 */
public enum TokenEnum {

    SUCCESS,
    FAILED;

    public boolean isSuccess() {
        return this.equals(SUCCESS);
    }

    public boolean isFailed() {
        return this.equals(FAILED);
    }

}

对应的 lua 脚本：

计数器算法

local key = "ratelimit:" .. KEYS[1]
local limit = tonumber(ARGV[1])
local expire_time = ARGV[2]

local is_exists = redis.call("EXISTS", key)
if is_exists == 1 then
    if redis.call("INCR", key) > limit then
        return 0
    else
        return 1
    end
else
    redis.call("SET", key, 1)
    redis.call("EXPIRE", key, expire_time)
    return 1
end

令牌桶算法

令牌桶初始化

local result=1
redis.pcall("HMSET",KEYS[1],
        "last_mill_second",ARGV[1],
        "curr_permits",ARGV[2],
        "max_burst",ARGV[3],
        "rate",ARGV[4],
        "app",ARGV[5])
return result

令牌桶算法

local ratelimit_info=redis.pcall("HMGET",KEYS[1],"last_mill_second","curr_permits","max_burst","rate","app")
local last_mill_second=ratelimit_info[1]
local curr_permits=tonumber(ratelimit_info[2])
local max_burst=tonumber(ratelimit_info[3])
local rate=tonumber(ratelimit_info[4])
local app=tostring(ratelimit_info[5])
if app == nil then
    return 0
end

local local_curr_permits=max_burst;

if(type(last_mill_second) ~='boolean' and last_mill_second ~=nil) then
    local reverse_permits=math.floor((ARGV[2]-last_mill_second)/1000)*rate
    if(reverse_permits>0) then
        redis.pcall("HMSET",KEYS[1],"last_mill_second",ARGV[2])
    end

    local expect_curr_permits=reverse_permits+curr_permits
    local_curr_permits=math.min(expect_curr_permits,max_burst);

else
    redis.pcall("HMSET",KEYS[1],"last_mill_second",ARGV[2])
end

local result=-1
if(local_curr_permits-ARGV[1]>=0) then
    result=1
    redis.pcall("HMSET",KEYS[1],"curr_permits",local_curr_permits-ARGV[1])
else
    redis.pcall("HMSET",KEYS[1],"curr_permits",local_curr_permits)
end

return result

测试类编写

package cn.texous.demo.dnw.utils;

import cn.texous.demo.dnw.DemoNormalWebApplicationTests;
import cn.texous.demo.dnw.common.constant.TokenEnum;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * insert description here
 *
 * @author Showa.L
 * @since 2019/8/21 17:56
 */
public class RateLimitClientTests extends DemoNormalWebApplicationTests {

    @Autowired
    private RateLimitClient rateLimitClient;

    @Test
    public void testGetToken() throws InterruptedException {
        int scount = 0;
        int fcount = 0;
        String base = "192.168.0.";
        String ip = base + "1";
        String key = rateLimitClient.getKey(ip);
        long start = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {
//            Long success = rateLimitClient.acquireToken(ip);
//            key = rateLimitClient.getKey(ip);
            if (!rateLimitClient.exists(key))
                rateLimitClient.initToken(ip);

            TokenEnum success = rateLimitClient.accquireToken(ip);
            if (success.isSuccess())
                scount++;
            else {
//                ip = base + i;
                fcount++;
            }
//            if (i % 500 == 0)
//                Thread.sleep(1000);
        }
        System.out.println(System.currentTimeMillis() - start);
        System.out.println("success count: " + scount);
        System.out.println("failed count: " + fcount);
    }


}

结语

令牌桶算法相关代码如上

参考文献

《redis+lua 实现分布式令牌桶，高并发限流》

《令牌桶算法》

《Redis + Lua Java实现限流》

Texous
关注
专栏目录
限流算法-令牌桶算法
北辰
09-18 813
常用的限流算法有令牌桶法和漏桶，而Google开源项目Guava中的RateLimiter使用的就是令牌桶算法。在使用令牌桶算法时需要引入如下依赖： <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>29.0-jre</version> </dependency&g
四、高并发系统限流机制——限流算法：令牌桶算法
流楚丶格念的博客
08-06 910
请求处理时间指系统从接收到请求到处理完成的时间，包括令牌的生成和消耗过程。此指标衡量系统响应速度。系统吞吐量指单位时间内系统能够处理的请求数量。高吞吐量表明系统能在高负载下维持良好性能。延迟指请求从提交到开始处理的时间，包括等待令牌的时间。延迟高时会影响用户体验。
令牌桶算法限流
热门推荐
SmartSi
04-23 2万+
今天观看QCon大会讲述了阿里线上管控体系，其中主要使用了令牌桶算法来实现限流的目的。表示非常好奇，故此学习一下什么是令牌桶算法。 1. 简介 令牌桶算法最初来源于计算机网络。在网络传输数据时，为了防止网络拥塞，需限制流出网络的流量，使流量以比较均匀的速度向外发送。令牌桶算法就实现了这个功能，可控制发送到网络上数据的数目，并允许突发数据的发送。 令牌桶算法是网络流量整形（Tr
【算法】令牌桶算法
wnm23的专栏
08-20 1347
令牌桶算法是一种有效的流量控制技术，能够平滑流量并限制突发请求。通过在桶中动态生成和管理令牌来限制数据发送速率。算法的核心原理是设置桶的容量和令牌生成速率，从而控制请求处理的速率，适用于网络流量控制和API限流等场景。相比其他算法（如漏桶算法、固定窗口计数等），令牌桶能更灵活地应对突发流量。
限流 -- 令牌桶算法
白羊座的橙子
12-26 1910
一、什么是令牌桶算法？三、单个Jvm应用的限流框架四、分布式的限流框架令牌桶算法是一种流量控制策略，用于限制请求数。它通过维护一个固定容量的“令牌桶”，并以恒定速率向其中添加令牌。当请求到达时，需要从桶中取出一个令牌才能被处理；如果没有可用的令牌，则请求将被拒绝或等待。
经典限流算法：令牌桶算法
whutrenzhe的博客
12-16 1273
Guava 的限流器使用上还是很简单的，那它是如何实现的呢？Guava 采用的是令牌桶算法，其核心是要想通过限流器，必须拿到令牌。也就是说，只要我们能够限制发放令牌的速率，那么就能控制流速了。令牌桶算法的详细描述如下： 令牌以固定的速率添加到令牌桶中，假设限流的速率是 r/ 秒，则令牌每 1/r 秒会添加一个； 假设令牌桶的容量是 b ，如果令牌桶已满，则新的令牌会被丢弃； 请求能够通过限流器的前提是令牌桶中有令牌。 这个算法中，限流的速率 r 还是比较容易理解的，但令牌桶的容量 b 该怎么理解呢？b 其实
接口限流——令牌桶算法2
08-08
**接口限流与令牌桶算法** 在高并发的分布式系统中，为了保护系统稳定性和服务质量，接口限流是一种常见的策略。它主要用于防止恶意用户或异常情况导致系统资源被过度消耗，确保关键服务的可用性。令牌桶算法是实现...
四、高并发系统限流大法——限流算法：漏桶算法
最新发布
流楚丶格念的博客
08-20 904
漏桶算法是一种用于流量控制的算法，通过一个“漏桶”来处理请求。请求被放入桶中，桶以固定速率“漏出”请求。如果桶满了，新请求将被丢弃或延迟。漏桶算法适用于需要平稳输出请求速率的场景，能够有效控制流量和负载。
令牌桶算法（token bucket algorithm）
07-20
令牌桶算法通过动态地管理令牌的添加和消耗，有效地控制了网络数据流的速率，确保了网络资源的合理分配。无论是用于流量监管还是流量整形，令牌桶算法都是实现QoS策略的重要手段之一。通过合理设置CIR、Bc和Tc等参数...
Guava —— RateLimiter 接口限流
Think In JAVA—Max
09-04 1295
限流==保险丝策略，可借助框架如spring cloud中Hystrix组件实现。今天介绍使用guava RateLimiter 类实现接口限流。 常见限流算法 漏桶算法      漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),然后就拒绝请求,可以看出漏桶算法能强行限制...
基于令牌桶算法的Java限流实现
02-23
基于令牌桶算法的Java限流实现。 项目需要使用限流措施，查阅后主要使用令牌桶算法实现，为了更灵活的实现限流，就自己实现了一个简单的基于令牌桶算法的限流实现。
令牌桶算法理解学习（限流算法）
nimo观察者
12-10 1659
在r=10，b=5时，即表明每1/r=0.1，每0.1秒投入一个令牌，而在到0.5秒时达到桶的极限容量5，在此刻继续投入令牌则无法维持，这些令牌将会被废弃，同时在此时若有5个指令同时想要去走令牌则可以同时取走令牌桶内的所有令牌，即为取走b=5个。令牌桶算法是网络流量整形（Traffic Shaping）和速率限制（Rate Limiting）中最常使用的一种算法。典型情况下，令牌桶算法用来控制发送到网络上的数据的数目，并允许突发数据的发送。
限流算法(令牌桶&漏桶&计数器)
m0_62645012的博客
05-13 1736
📝⛺️稳中求进，晒太阳业务重的三种情况：突发流量、恶意流量、业务本身需要是为了保护自身系统和下游系统不被高并发流量冲垮，导致系统雪崩。保证系统在可用的情况下尽可能增加进入的请求，其余的请求在排队等待，或者返回友好提示。保证进入系统的用户可以友好使用。
高并发系统限流-漏桶算法和令牌桶算法
weixin_30426065的博客
06-01 456
高并发系统限流-漏桶算法和令牌桶算法 参考： http://www.cnblogs.com/LBSer/p/4083131.html https://blog.csdn.net/scorpio3k/article/details/53103239 https://www.cnblogs.com/clds/p/5850070.html http://jinnianshilongni...
令牌桶限流算法
怀揣梦想，一颗执着于技术的心从未磨灭，内心住着一颗顽强的小强时刻提醒自己层层突破自我，同时也成就他人
03-22 335
令牌桶算法，是增加一个大小固定的容器，也就是令牌桶，系统以恒定的速率向令牌桶中放入令牌，如果有客户端来请求，先需要从令牌桶中一拿个令牌，拿到令牌，才有资格访问访问系统，这时令牌中少一个令牌。当令牌桶满的时候，再向令牌桶生成令牌时，令牌会被抛弃。1、请求速度大于令牌的生成速度：那么令牌桶中令牌会被取完，后续再进来的请求，由于拿不到令牌，会被限流。3、请求速度小于令牌的生成速度：那么此时系统的访问量远远低于系统的并发能力，请可以被正常处理。令牌桶算法，由于有一个桶的存在，可以处理短时间大流量的场景。
用令牌桶算法完成API接口限流
张富涛的博客
03-19 698
这是张富涛的第15篇原创 用令牌桶算法完成API接口限流 本文介绍了“令牌桶算法”，和使用lua+redis实现基于令牌桶算法的限流。 1. 限流需求的产生背景 软件开发时偶尔会面临高并发或突发流量，经典的情况是秒杀业务或者是某明星发了爆炸性的微博，很可能因为下游的服务器处理能力不足导致程序异常，甚至造成服务雪崩。 面对高并发或突发流量场景的解决方案之一是“限流”，通过在架构中的网关层进行限制单位时间内的最大请求数量，达到保护后端服务的作用。 熟悉淘宝双11的读者一定见过这个截图，这样的截图一般更容易.
令牌桶算法实现限流
big_white_py的博客
05-19 4899
试想这样的场景, 尽管服务器的 QPS 已经达到限速阈值了, 但是并不想将所有的流量都拒之门外, 仍然让部分流量能够正常通过限流器. 这样我们的服务器在面对突发流量时能够有一定的伸缩空间, 而不是一直处于不可用状态。 在开发高并发的系统时，有很多手段来保护系统，如缓存、降级和限流等。缓存可以提升系统的访问速度，降级可以暂时屏蔽掉非核心业务，使得核心业务不受影响。限流的目的通过对并发访问进行限速，一旦达到一定的速率就可以拒绝服务（定向到错误页或告知资源没有了）、排队等待（如秒杀、评论、下单等）、降级（直接返回
系统优化：限流策略详解——固定窗口、滑动窗口与漏桶算法
"本文主要介绍了三种常见的限流策略——固定窗口限流、滑动窗口限流和漏桶限流，以及它们在系统优化中的应用。此外，还提到了服务器安全性和数据存储优化的方法，包括文件上传的校验和数据表的分库分表策略。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值