Java实现系统限流的示例代码

更新时间：2023年09月04日 10:23:42 作者：不焦躁的程序员

限流是保障系统高可用的方式之一,也是大厂高频面试题,它在微服务系统中,缓存、限流、熔断是保证系统高可用的三板斧,所以本文我们就来聊聊如何实现系统限流吧

1、Guava RateLimiter

Guava是Java领域很优秀的开源项目，包含了日常开发常用的集合、String、缓存等，其中RateLimiter是常用限流工具。

RateLimiter是基于令牌桶算法实现的，如果每秒10个令牌，内部实现，会每100ms生产1个令牌。

使用Guava RateLimiter，如下：

1.引入pom依赖：

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

2.代码：

public class GuavaRateLimiterTest {
    //比如每秒生产10个令牌，相当于每100ms生产1个令牌
    private RateLimiter rateLimiter = RateLimiter.create(10);
    /**
     * 模拟执行业务方法
     */
    public void exeBiz() {
        if (rateLimiter.tryAcquire(1)) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程" + Thread.currentThread().getName() + "：执行业务逻辑");
        } else {
            System.out.println("线程" + Thread.currentThread().getName() + "：被限流");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        GuavaRateLimiterTest limiterTest = new GuavaRateLimiterTest();
        Thread.sleep(500);//等待500ms，让limiter生产一些令牌
        //模拟瞬间生产100个线程请求
        for (int i = 0; i < 100; i++) {
            new Thread(limiterTest::exeBiz).start();
        }
    }
}

2、滑窗计数

打个比方，某接口每秒允许100个请求，设置一个滑窗，窗口中有10个格子，每个格子占100ms，每100ms移动一次。滑动窗口的格子划分的越多，滑动窗口的滚动就越平滑，限流的统计就会越精确。

代码如下：

/**
 * 滑窗计数器
 */
public class SliderWindowRateLimiter implements Runnable {
    //每秒允许的最大访问数
    private final long maxVisitPerSecond;
    //将每秒时间划分N个块
    private final int block;
    //每个块存储的数量
    private final AtomicLong[] countPerBlock;
    //滑动窗口划到了哪个块儿，可以理解为滑动窗口的起始下标位置
    private volatile int index;
    //目前总的数量
    private AtomicLong allCount;
    /**
     * 构造函数
     *
     * @param block，每秒钟划分N个窗口
     * @param maxVisitPerSecond 每秒最大访问数量
     */
    public SliderWindowRateLimiter(int block, long maxVisitPerSecond) {
        this.block = block;
        this.maxVisitPerSecond = maxVisitPerSecond;
        countPerBlock = new AtomicLong[block];
        for (int i = 0; i < block; i++) {
            countPerBlock[i] = new AtomicLong();
        }
        allCount = new AtomicLong(0);
    }
    /**
     * 判断是否超过最大允许数量
     *
     * @return
     */
    public boolean isOverLimit() {
        return currentQPS() > maxVisitPerSecond;
    }
    /**
     * 获取目前总的访问数
     *
     * @return
     */
    public long currentQPS() {
        return allCount.get();
    }
    /**
     * 请求访问进来，判断是否可以执行业务逻辑
     */
    public void visit() {
        countPerBlock[index].incrementAndGet();
        allCount.incrementAndGet();
        if (isOverLimit()) {
            System.out.println(Thread.currentThread().getName() + "被限流" + "，currentQPS：" + currentQPS() + "，index：" + index);
        } else {
            System.out.println(Thread.currentThread().getName() + "执行业务逻辑" + "，currentQPS：" + currentQPS() + "，index：" + index);
        }
    }
    /**
     * 定时执行器，
     * 每N毫秒滑块移动一次，然后再设置下新滑块的初始化数字0，然后新的请求会落到新的滑块上
     * 同时总数减掉新滑块上的数字，并且重置新的滑块上的数量
     */
    @Override
    public void run() {
        index = (index + 1) % block;
        long val = countPerBlock[index].getAndSet(0);
        allCount.addAndGet(-val);
    }
    public static void main(String[] args) {
        SliderWindowRateLimiter sliderWindowRateLimiter = new SliderWindowRateLimiter(10, 100);
        //固定的速率移动滑块
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        scheduledExecutorService.scheduleAtFixedRate(sliderWindowRateLimiter, 100, 100, TimeUnit.MILLISECONDS);
        //模拟不同速度的请求
        new Thread(() -> {
            while (true) {
                sliderWindowRateLimiter.visit();
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //模拟不同速度的请求
        new Thread(() -> {
            while (true) {
                sliderWindowRateLimiter.visit();
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

3、信号量

利用Semaphore，每隔固定速率，释放Semaphore的资源。线程获取到资源，则执行业务代码。

代码如下：

public class SemaphoreOne {
    private static Semaphore semaphore = new Semaphore(10);
    public static void bizMethod() throws InterruptedException {
        if (!semaphore.tryAcquire()) {
            System.out.println(Thread.currentThread().getName() + "被拒绝");
            return;
        }
        System.out.println(Thread.currentThread().getName() + "执行业务逻辑");
        Thread.sleep(500);//模拟处理业务逻辑需要1秒
        semaphore.release();
    }
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                semaphore.release(10);
                System.out.println("释放所有锁");
            }
        }, 1000, 1000);
        for (int i = 0; i < 10000; i++) {
            try {
                Thread.sleep(10);//模拟每隔10ms就有1个请求进来
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            new Thread(() -> {
                try {
                    SemaphoreOne.bizMethod();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

4、令牌桶

令牌桶算法：一个存放固定容量令牌的桶，按照固定速率往桶里添加令牌，如有剩余容量则添加，没有则放弃。如果有请求进来，则需要先从桶里获取令牌，当桶里没有令牌可取时，则拒绝任务。

令牌桶的优点是：可以改变添加令牌的速率，一旦提高速率，则可以处理突发流量。

代码如下：

public class TokenBucket {
    /**
     * 定义的桶
     */
    public class Bucket {
        //容量
        int capacity;
        //速率，每秒放多少
        int rateCount;
        //目前token个数
        AtomicInteger curCount = new AtomicInteger(0);
        public Bucket(int capacity, int rateCount) {
            this.capacity = capacity;
            this.rateCount = rateCount;
        }
        public void put() {
            if (curCount.get() < capacity) {
                System.out.println("目前数量==" + curCount.get() + ", 我还可以继续放");
                curCount.addAndGet(rateCount);
            }
        }
        public boolean get() {
            if (curCount.get() >= 1) {
                curCount.decrementAndGet();
                return true;
            }
            return false;
        }
    }
    @Test
    public void testTokenBucket() throws InterruptedException {
        Bucket bucket = new Bucket(5, 2);
        //固定线程，固定的速率往桶里放数据，比如每秒N个
        ScheduledThreadPoolExecutor scheduledCheck = new ScheduledThreadPoolExecutor(1);
        scheduledCheck.scheduleAtFixedRate(() -> {
            bucket.put();
        }, 0, 1, TimeUnit.SECONDS);
        //先等待一会儿，让桶里放点token
        Thread.sleep(6000);
        //模拟瞬间10个线程进来拿token
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                if (bucket.get()) {
                    System.out.println(Thread.currentThread() + "获取到了资源");
                } else {
                    System.out.println(Thread.currentThread() + "被拒绝");
                }
            }).start();
        }
        //等待，往桶里放token
        Thread.sleep(3000);
        //继续瞬间10个线程进来拿token
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                if (bucket.get()) {
                    System.out.println(Thread.currentThread() + "获取到了资源");
                } else {
                    System.out.println(Thread.currentThread() + "被拒绝");
                }
            }).start();
        }
    }
}

5、总结

本文主要介绍了几种限流方法：Guava RateLimiter、简单计数、滑窗计数、信号量、令牌桶，当然，限流算法还有漏桶算法、nginx限流等等。我所写的这些方法只是个人在实际项目总使用过的，或者是早年参加阿里笔试时写过的方式。

以上就是Java实现系统限流的示例代码的详细内容，更多关于Java系统限流的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

java
限流

SpringBoot整合Flyway实现数据库的初始化和版本管理操作
Flyway 是一款开源的数据库版本管理工具，它可以很方便的在命令行中使用，或者在Java应用程序中引入，用于管理我们的数据库版本，这篇文章主要介绍了SpringBoot整合Flyway实现数据库的初始化和版本管理,需要的朋友可以参考下
2023-06-06
MyBatis-Plus集成Druid环境搭建的详细教程
这篇文章主要介绍了MyBatis-Plus集成Druid环境搭建的详细教程,需要的朋友可以参考下
2020-08-08
关于Java企业级项目开发思想
Java企业级项目开发思想。偶遇，读有所得，遂分享给大家，本文不涉及案例，只谈思想和理念，需要的朋友可以参考。
2017-09-09
Springboot四种事件监听的实现方式详解
这篇文章主要介绍了Springboot四种事件监听的实现方式,事件监听是一种机制,可以定义和触发自定义的事件,以及在应用程序中注册监听器来响应这些事件,需要的朋友可以参考下
2022-06-06
SpringMVC 接收前端传递的参数四种方式小结
这篇文章主要介绍了SpringMVC 接收前端传递的参数四种方式小结，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-10-10
使用Spring Boot Mybatis 搞反向工程的步骤
这篇文章主要介绍了使用Spring Boot Mybatis 搞反向工程的步骤，帮助大家更好的理解和使用spring boot框架，感兴趣的朋友可以了解下
2021-01-01
Java实现微信公众平台朋友圈分享功能详细代码
这篇文章主要介绍了Java实现微信公众平台朋友圈分享功能详细代码，小编觉得挺不错的，这里分享给大家，供需要的朋友参考。
2017-11-11
spring boot3整合AI组件及使用方法
本文介绍了springboot开发后端服务中,AI组件(Spring AI)的整合与使用,本文通过实例代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧
2024-05-05
springboot docker原理及项目构建
这篇文章主要介绍了springboot docker原理及项目构建,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-11-11
SpringBoot中的事务配置管理详解
这篇文章主要介绍了SpringBoot中的事务配置管理详解,Spring Boot 默认的事务规则是遇到运行异常(RuntimeException)和程序错误(Error)才会回滚,但是抛出SQLException就无法回滚了,需要的朋友可以参考下
2024-01-01