Java并发编程实战pdf百度网盘，谈谈架构中的限流与计数器的实现方式

private int limtCount = 60;// 限制最大访问的容量
AtomicInteger atomicInteger = new AtomicInteger(0); // 每秒钟 实际请求的数量
private long start = System.currentTimeMillis();// 获取当前系统时间
private int interval = 60*1000;// 间隔时间60秒
public boolean acquire() {
    long newTime = System.currentTimeMillis();
    if (newTime > (start + interval)) {
        // 判断是否是一个周期
        start = newTime;
        atomicInteger.set(0); // 清理为0
        return true;
    }
    atomicInteger.incrementAndGet();// i++;
    return atomicInteger.get() <= limtCount;
}
static EnjoyCountLimit limitService = new EnjoyCountLimit();
public static void main(String[] args) {
    ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
    for (int i = 1; i < 100; i++) {
        final int tempI = i;
        newCachedThreadPool.execute(new Runnable() {
            public void run() {
                if (limitService.acquire()) {
                    System.out.println("你没有被限流,可以正常访问逻辑 i:" + tempI);
            } else {
                    System.out.println("你已经被限流呢  i:" + tempI);
                }
            }
        });
    }
}

}

![](https://s2.51cto.com/images/20210807/1628316021236828.jpg)
还是以60运行访问10次请求为例，在第一次0-58秒之内，没有访问请求，在59秒之内突然来了10次请求，这个时候会做什么，由于已经到了1分钟计数器会重置。

这个时候第二次的1秒内（1分0秒）又有了10请求，这个时候是不是就在2秒之内有20个请求被放行了呢？（59秒，1分0秒），如果某个服务器的访问量只能是10次请求，那这种限流方式已经导致服务器挂了。

滑动窗口计数器

前面已经知道简单的计数器的实现方式，也知道他会出现的一些问题，虽然这些问题举得有些极端，但还是有更好的解决方案，这方案就是使用滑动窗口计数器。

滑动窗口计数器的原理是在请求还没过来的时候，先判断前面N个单位内的总访问量是否超过阈值，并且在当前的时间单位的请求数上+1。

![](https://s2.51cto.com/images/20210807/1628316022174964.jpg)
![](https://s2.51cto.com/images/20210807/1628316023677890.jpg)
```java
import java.util.concurrent.atomic.AtomicInteger;
public class EnjoySlidingWindow {
    private AtomicInteger[] timeSlices;
    /* 队列的总长度  */
    private final int timeSliceSize;
    /* 每个时间片的时长 */
    private final long timeMillisPerSlice;
    /* 窗口长度 */
    private final int windowSize;
    /* 当前所使用的时间片位置 */
    private AtomicInteger cursor = new AtomicInteger(0);
    public static enum Time {
        MILLISECONDS(1),
        SECONDS(1000),
        MINUTES(SECONDS.getMillis() * 60),
        HOURS(MINUTES.getMillis() * 60),
        DAYS(HOURS.getMillis() * 24),
        WEEKS(DAYS.getMillis() * 7);
        private long millis;
        Time(long millis) {
            this.millis = millis;
        }
        public long getMillis() {
            return millis;
        }
    }
    public EnjoySlidingWindow(int windowSize, Time timeSlice) {
        this.timeMillisPerSlice = timeSlice.millis;
        this.windowSize = windowSize;
        // 保证存储在至少两个window
        this.timeSliceSize = windowSize * 2 + 1;
        init();
    }
    /**
     * 初始化
     */
    private void init() {
        AtomicInteger[] localTimeSlices = new AtomicInteger[timeSliceSize];
        for (int i = 0; i < timeSliceSize; i++) {
            localTimeSlices[i] = new AtomicInteger(0);
        }
        timeSlices = localTimeSlices;
    }
    private int locationIndex() {
        long time = System.currentTimeMillis();
        return (int) ((time / timeMillisPerSlice) % timeSliceSize);
    }
    /**
     * <p>对时间片计数+1，并返回窗口中所有的计数总和
     * <p>该方法只要调用就一定会对某个时间片进行+1
     * @return
     */
    public int incrementAndSum() {
       int index = locationIndex();
        int sum = 0;
        // cursor等于index，返回true
        // cursor不等于index，返回false，并会将cursor设置为index
        int oldCursor = cursor.getAndSet(index);
        if (oldCursor == index) {
            // 在当前时间片里继续+1
            sum += timeSlices[index].incrementAndGet();
        } else {
            //轮到新的时间片，置0，可能有其它线程也置了该值，容许
            timeSlices[index].set(0);
            // 清零，访问量不大时会有时间片跳跃的情况
            clearBetween(oldCursor, index);
            sum += timeSlices[index].incrementAndGet();
        }
        for (int i = 1; i < windowSize; i++) {
            sum += timeSlices[(index - i + timeSliceSize) % timeSliceSize].get();
        }
        return sum;
    }
    /**
     * 判断是否允许进行访问，未超过阈值的话才会对某个时间片+1
     * @param threshold
     * @return
     */
    public boolean allow(int threshold) {
        int index = locationIndex();
        int sum = 0;
        int oldCursor = cursor.getAndSet(index);
        if (oldCursor != index) {
            timeSlices[index].set(0);
            clearBetween(oldCursor, index);
        }
        for (int i = 0; i < windowSize; i++) {
            sum += timeSlices[(index - i + timeSliceSize) % timeSliceSize].get();
![](https://s2.51cto.com/images/20210807/1628316023752214.jpg)# 总结

虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。

架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。

如果你也想成为一名好的架构师，那或许这份**Java成长笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

**资料领取方式：戳这里免费下载**

![image](https://s2.51cto.com/images/20210807/1628316024699692.jpg)