栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【Spring Web教程】Java常见12种限流方式和算法总结

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【Spring Web教程】Java常见12种限流方式和算法总结

概况

在用户并发量比较大的情况下,服务会发生雪崩效应:用户同时请求堆积在一个接口,导致其它的接口服务无法访问,这种效果给到用户体验不好。本章分别描述常见的限流算法。

常见限流

单机版本限流:

计数器限流:AtomicInteger、Semaphore信号量、Semaphore控制并发量;

滑动窗口限流算法;

Guava令牌桶限流;

漏桶限流;


微服务限流方式:

Alibaba Sentinel限流(底层采用滑动窗口算法);

SpringCloud Hystrix限流(底层采用滑动窗口算法);

网关统一设置限流;


分布式限流:

Redis + Lua分布式限流;


应用层限流

Nginx 设置限流;

SpringBoot 配置Tomcat参数限流;


简单计数器限流算法

通过线程安全类,在指定时间内对客户端限流。通过计数器不需要引入任何其它第三方插件、非常简单。

缺点:对限流无法更精细控制控制。

在Java中有常见的两种计数器限流算法:AtomicInteger、Semaphore信号量

AtomicInteger实现计数器限流算法

需求:控制一分钟只能访问十次。

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;


@RestController
@RequestMapping("/counter")
public class CounterCtrl {

    // 控制一分钟只能访问十次
    public static AtomicInteger atomicCount = new AtomicInteger(0);
    // 时间搓
    public static AtomicLong atomicTime = new AtomicLong(System.currentTimeMillis());

    @RequestMapping("/testAtomic")
    public String testAtomic(){
        // 换算成间隔多少秒
        long second = (System.currentTimeMillis() - atomicTime.get()) / 1000;
        // 如果时间大于1分钟 清零
        if (second > 60) {
            atomicCount.set(0);
            atomicTime.set(System.currentTimeMillis());
        }
        atomicCount.incrementAndGet();
        if (atomicCount.get() > 10) {
            return "返回失败!" + second + "秒,访问次数" + atomicCount.get();
        }
        return "返回成功!" + second + "秒,访问次数" + atomicCount.get();
    }

}

打印如下:

返回成功!5秒,访问次数7

返回失败!17秒,访问次数11

等待一分钟后访问:

返回成功!2秒,访问次数2
Semaphore实现计数器限流算法

Semaphore信号量是Java AQS下的并发组件。

@RestController
@RequestMapping("/counter")
public class CounterCtrl {

    // 控制一分钟只能访问十次
    public static AtomicInteger atomicCount = new AtomicInteger(0);
    // 时间搓
    public static AtomicLong atomicTime = new AtomicLong(System.currentTimeMillis());

    @RequestMapping("/testAtomic")
    public String testAtomic(){
        // 换算成间隔多少秒
        long second = (System.currentTimeMillis() - atomicTime.get()) / 1000;
        // 如果时间大于1分钟 清零
        if (second > 60) {
            atomicCount.set(0);
            atomicTime.set(System.currentTimeMillis());
        }
        atomicCount.incrementAndGet();
        if (atomicCount.get() > 10) {
            return "返回失败!" + second + "秒,访问次数" + atomicCount.get();
        }
        return "返回成功!" + second + "秒,访问次数" + atomicCount.get();
    }

    // 信号量:控制一分钟只能访问十次
    public static Semaphore semaphore = new Semaphore(10);
    // 时间搓
    public static AtomicLong semaphoreTime = new AtomicLong(System.currentTimeMillis());

    @RequestMapping("/testSemaphore")
    public String testSemaphore(){
        // 换算成间隔多少秒
        long second = (System.currentTimeMillis() - semaphoreTime.get()) / 1000;
        // 如果时间大于1分钟 清零
        if (second > 60) {
            semaphore.release(10);
            semaphoreTime.set(System.currentTimeMillis());
        }
        // 非阻塞tryAcquire
        if (!semaphore.tryAcquire()) {
            return "返回失败!" + second + "秒,剩余次数" + semaphore.availablePermits();
        }
        return "返回成功!" + second + "秒,剩余次数" + semaphore.availablePermits();
    }

}

打印如下:

返回成功!3秒,剩余次数9

返回成功!7秒,剩余次数7

返回失败!24秒,剩余次数0

等待一分钟后访问:

返回成功!2秒,剩余次数8
Semaphore控制接口并发量

上面讲到Semaphore计数器限流算法的实现,现在单纯控制接口并发量。

假设:并发量控制4,接口请求需要10秒,代码实现。

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;


@RestController
@RequestMapping("/counter")
public class CounterCtrl {

    public static Semaphore testSemaphoreQPS = new Semaphore(2);

    
    @RequestMapping("/testSemaphoreQPS")
    public String testSemaphoreQPS() throws InterruptedException {
        // 非阻塞tryAcquire
        if (!testSemaphoreQPS.tryAcquire()) {
            return "接口请求过于频繁!当前剩余人数" + testSemaphoreQPS.availablePermits();
        }
        // 模拟业务处理10秒
        Thread.sleep(1000 * 10);
        // 处理完释放
        testSemaphoreQPS.release();
        return "返回成功!" + testSemaphoreQPS.availablePermits();
    }

}

开3个谷歌窗口打印如下:

返回成功!2

返回成功!1

接口请求过于频繁!当前剩余人数0

等待10秒后访问

返回成功!2
滑动窗口计数器限流算法

计数器限流算法存在一个问题,比如60秒内控制10个并发,如果用户在59秒、61秒 都请求了10次,那么实则是2秒钟请求了20次,就会无法精准控制限流的问题。

滑动窗口就是解决这个问题:如滑动窗口算法在60秒控制10个请求,会提前分割号10个单元格,每个单元格就是6秒钟,每隔6秒就会淘汰前面的单元格。

缺点:实现相对复杂。

令牌桶算法

令牌桶算法原理是每隔一段时间生成一个资源,客户端去拿资源。如果能够获取令牌则操作业务,没有则限制访问。

Java中令牌桶开源框架guava。

guava实现限流

pom.xml



    com.google.guava
    guava
    31.1-jre

代码实现

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/rateLimit")
public class RateLimitCtrl {

    // 每秒2个令牌
    static RateLimiter rateLimiter = RateLimiter.create(2);

    
    @RequestMapping("/test")
    public String test(){
        // 非阻塞,如果获取不到则直接返回
        if (!rateLimiter.tryAcquire()) {
            return "请稍后重试!";
        }
        return "返回成功!";
    }

}

测试:http://localhost:8080/rateLimit/test

返回成功!

返回成功!

请稍后重试!

小提示:可以封装一个RateLimiter注解,这样更轻量级实现。

Alibaba Sentinel限流

相对于单机版本的,Alibaba Sentinel有控制台更加方便管理,除控制台外还可以通过注解,详细参考往期博客:

【SpringCloud教程】7.SpringCloud Alibaba服务保护Sentinel

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/955704.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号