1. 池化技术

池化资源技术的限流其实就是通过计算器算法来控制全局的总并发数，例如常用的线程池中核心线程数和最大线程数的设置、数据库连接池中对于最大连接数的限制等等。就数据库连接池技术而言，为了避免并发场景下连接数超过数据库所能承载的最大上限，合理的运用连接池技术，可以有效的限制单个进程内能够申请到的最大连接数，确保在并发环境下连接数不会超过资源阈值。

2. 令牌桶算法

令牌桶算法主要用于限制流量的平均流入速率，并允许出现一定程度上的突发流量，假设令牌桶的容量为$n$，

那么算法执行的流程为：

• 每秒向令牌桶中放入$n$个令牌，即每$\frac{1}{n}$秒放入一个令牌的平均速率来提供可以使用的令牌
• 令牌桶的容量自始至终都是固定的，最多只能放入$n$个令牌，桶满则溢出
• 当一个$n$个字节的请求包到达时，将消耗$n$个令牌，然后再发送该数据包
• 如果桶中的令牌数小于$n$，则该数据包将被执行限流处理

Guava Cache中的RateLimiter抽象类能够以一种简便的方式实现流量的平均流入速率限流，起到类似令牌桶算法的效果，

为了使用Guava Cache，首先需要创建工程，导入依赖

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

如果想要使用RateLimiter，可以调用它的create()来指定令牌桶的容量。当需要令牌时，请求需要调用acquire()方法。如下所示，此时令牌桶容量为5，假设请求数也是5，那么5个请求都可以近乎同时获取令牌，并不会触发限流。

@Test
void testLimit(){
    RateLimiter limiter = RateLimiter.create(5);
    for (int i = 0; i < 5; i++) {
        double waitTime = limiter.acquire();
        System.out.println(waitTime); 
    }
}

0.0
0.198812
0.199176
0.199727
0.19905

如果此时有了突发流量，某个请求需要一次申请5个令牌，那么后续的请求就会被限流。大约等待1秒后，后续请求才可以继续从桶中拿令牌。

@Test
void testLimitMore() {
    RateLimiter limiter = RateLimiter.create(5);
    for (int i = 0; i < 5; i++) {
        System.out.println(limiter.acquire(5));
        System.out.println(limiter.acquire());
        System.out.println("--------");
    }
}

0.0
0.999008
--------
0.198522
0.998839
--------
0.199423
0.999741
--------
0.196243
0.999406
--------
0.199218
0.99949
--------

调用acquire()获取令牌不到，请求将会一直等待。如果需要请求在获取不到令牌后，直接丢弃或是短暂等待，可以调用tryAcquire()的无参和带参形式。那么RateLimiter底层是如何实现流量的平均流入速率限流的效果的呢？下面我们通过源码看一下它的create()、acquire()和tryacquire()的实现。

RateLimiter的create()最基本的实现如下：

public static RateLimiter create(double permitsPerSecond) {
    return create(permitsPerSecond, RateLimiter.SleepingStopwatch.createFromSystemTimer());
}

其中的permitsPerSecond可用于设置限流速率从慢速过渡到平均速率的缓存时间。当前，RateLimiter中还提供了其他重载的形式，用于创建不同需求的limiter。acquire()的实现如下：

@CanIgnoreReturnValue
public double acquire() {
    return acquire(1);
}

@CanIgnoreReturnValue
public double acquire(int permits) {
    // 计算获取令牌所需等待的时间
    long microsToWait = reserve(permits);
     // 进行线程sleep
    stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return 1.0 * microsToWait / SECONDS.toMicros(1L);
}

它会根据设置的桶容量来计算获取一个令牌所需要等待的时间。tryacquire()的实现如下：

public boolean tryAcquire(int permits) {
    return tryAcquire(permits, 0, MICROSECONDS);
}

public boolean tryAcquire(int permits, long timeout, TimeUnit unit) {
    long timeoutMicros = max(unit.toMicros(timeout), 0);
    checkPermits(permits);
    long microsToWait;
    synchronized (mutex()) {
        long nowMicros = stopwatch.readMicros();
        if (!canAcquire(nowMicros, timeoutMicros)) {
            return false;
        } else {
            microsToWait = reserveAndGetWaitLength(permits, nowMicros);
        }
    }
    stopwatch.sleepMicrosUninterruptibly(microsToWait);
    return true;
}

RateLimiter具体的源码解析阅读：

使用Guava RateLimiter限流以及源码解析

超详细的Guava RateLimiter限流原理解析

3. 漏桶算法

漏桶算法允许以任意的速率向桶中流入水滴，但由于桶的容量是固定的，如果桶已满，那么水滴将溢出被丢弃。而且桶流出水滴的速率是固定的，起到限制数据的传输速率。

上述两种算法虽然都可以在高并发场景下起到限流的效果，但是两者的限流方向是相反的。令牌桶算法限制的是向桶中放入令牌的数量，允许一定程度上的突发流量。当用户请求所需的令牌数多于桶中剩下的令牌数，就会被执行限流操作。

而漏桶算法控制的是令牌流出的速率，并且流出的速率还是固定的，主要用于平滑网络流量。例如，假设桶只能接受大小为10的数据包，那么当数据包大于10时，请求将被执行限流处理，由于流出速率固定，那么每秒处理的数据包大小将固定，从而起到平滑流量的作用。

4. 计数器算法

单位时间内会有一个计数器负责计数，不停的和阈值进行比较，当等于阈值时触发限流逻辑。它主要用于限制单位时间内的总并发数，假设规定每秒可以处理的请求数为100，那么一秒内请求一次，计数器值加1。如果一秒内计数器值到达阈值，那么后续的请求就被执行限流处理。并且只有达到临界值时，计数器才会被重置。

当等于阈值时触发限流逻辑。它主要用于限制单位时间内的总并发数，假设规定每秒可以处理的请求数为100，那么一秒内请求一次，计数器值加1。如果一秒内计数器值到达阈值，那么后续的请求就被执行限流处理。并且只有达到临界值时，计数器才会被重置。

1.思维流程图：

2.代码如下

<?php
class RateLimit
{
    private $minNum = 100; //单个用户每分访问数
	
	//主函数
    public function handle($uid)
    {
        $minNumKey = $uid . '_minNum';
        $dayNumKey = $uid . '_dayNum';
        $resMin    = $this->getRedis($minNumKey, $this->minNum, 60);
        if (!$resMin['status']) {
            return ['status'=>0,'info'=>'人数较多,请稍候'];
        }else{
            return ['status'=>1,'info'=>'正常'];
        }
    }


    protected function getRedis($key, $initNum, $expire)
    {
        $nowtime  = time();
        $result   = ['status' => true, 'msg' => ''];
        $ip = "127.0.0.1"; 
        $port = 6379; 
        $redis = new \Redis();
        $redis->connect($ip, $port);
        $redis->watch($key);
        $limitVal = $redis->get($key);
        if ($limitVal) {
            $limitVal = json_decode($limitVal, true);
            $newNum   = min($initNum, ($limitVal['num'] - 1) + (($initNum / $expire) * ($nowtime - $limitVal['time'])));
            if ($newNum > 0) {
                $redisVal = json_encode(['num' => $newNum, 'time' => time()]);
            } else {
                return ['status' => false, 'msg' => '当前时刻令牌消耗完！'];
            }
        } else {
            $redisVal = json_encode(['num' => $initNum, 'time' => time()]);
        }
        $redis->multi();
        $redis->set($key, $redisVal);
        $rob_result = $redis->exec();
        if (!$rob_result) {
            $result = ['status' => false, 'msg' => '访问频次过多！'];
        }
        return $result;
    }
}

介绍

令牌桶算法：
一个存放固定容量令牌的桶，按照固定速率往桶里添加令牌；如下：
a.假设是2r/s，则每500毫秒添加n个令牌；
b.桶中最多存放x个令牌，桶满时，再添加会拒绝；
c.请求去获取令牌，如果令牌足够，允许通过；如果令牌不足，拒绝请求或放入缓冲区等待；

漏桶算法：
漏桶容量固定，按照固定速率流出水滴；如果桶是空的，不用流，如果桶满了，再流入水滴，则拒绝服务。

区别

令牌桶控制的是平均流入速率，速率可高可低，允许有突发请求；漏桶控制的是恒定的流出速率，从而平滑流入速率。

java实现

令牌桶算法：

package com.cvnavi.oa.report;

import org.apache.kafka.common.protocol.types.Field;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TokenLimiter {

    private ArrayBlockingQueue<String> blockingQueue;

    //容量大小
    private int limit;

    //令牌的产生间隔
    private int period;

    //令牌每次产生的个数
    private int amount;

    public TokenLimiter(int limit, int period, int amount) {
        this.limit = limit;
        this.period = period;
        this.amount = amount;

        blockingQueue = new ArrayBlockingQueue<>(limit);
    }

    private void init() {
        for(int i = 0; i < limit; i++) {
            blockingQueue.add("lp");
        }
    }

    private void addToken(int amount) {
        for(int i = 0; i < amount; i++) {
            //溢出返回false
            blockingQueue.offer("lp");
        }
    }

    /**
     * 获取令牌
     * @return
     */
    public boolean tryAcquire() {
        //队首元素出队
        return blockingQueue.poll() != null ? true : false;
    }

    /**
     * 生产令牌
     */
    private void start(Object lock) {
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(() -> {
            synchronized (lock) {
                addToken(this.amount);
                lock.notify();
            }
        }, 500, this.period, TimeUnit.MILLISECONDS);
    }

    /**
     * 先生产2个令牌，减少4个令牌；再每500ms生产2个令牌，减少4个令牌
     */
    public static void main(String[] args) throws InterruptedException {
        int period = 500;
        TokenLimiter limiter = new TokenLimiter(8, period, 2);
        limiter.init();

        Object lock = new Object();
        limiter.start(lock);

        //让线程先产生2个令牌(溢出)
        synchronized (lock) {
            lock.wait();
        }
        for(int i = 0; i < 8; i++) {
            for(int j = 0; j < 4; j++) {
                String s = i + "，" + j + "：";
                if(limiter.tryAcquire()) {
                    System.out.println(s + "拿到令牌");
                }
                else{
                    System.out.println(s + "拒绝");
                }
            }
            Thread.sleep(period);
        }
    }

}

package com.cvnavi.report;

public class Funnel {

    //漏斗容量
    int capacity;
    //漏水速度
    double leakingRate;
    //漏斗剩余空间(不是水的大小)
    int leftQuota;
    //上次漏斗漏水的时间
    long leakingTs;

    public Funnel(int capacity, double leakingRate, int leftQuota, long leakingTs) {
        this.capacity = capacity;
        this.leakingRate = leakingRate;
        this.leftQuota = leftQuota;
        this.leakingTs = leakingTs;
    }

    private void makeSpace() {
        long nowTs = System.currentTimeMillis();
        //这个是间隔的时间
        long deltaTs = nowTs - this.leakingTs;
        //漏掉的水
        int deltaQuota = (int)(deltaTs * leakingRate);
        //间隔时间太长,溢出
        if (deltaQuota < 0){
            this.leftQuota = capacity;
            this.leakingTs = nowTs;
            return;
        }
        //说明漏的时间不够
        if (deltaQuota < 1) {
            return;
        }
        this.leakingTs = nowTs;
        this.leftQuota = this.leftQuota + deltaQuota;
        if (this.leftQuota > this.capacity) {
            this.leftQuota = this.capacity;
        }
    }

    /**
     * 流入
     * @param quota
     * @return
     */
    public Boolean water(int quota) {
        makeSpace();
        //表示量充足
        if (leftQuota >= quota){
            leftQuota =  leftQuota - quota;
            return true;
        }
        //剩余量不够
        return false;
    }

}


package com.cvnavi.report;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class FunnelLimitRate {

    private static Map<String,Funnel> funnels = new HashMap<>();


    public static void main(String[] args) throws InterruptedException {
        String userId= "2019";
        String actionKey = "rgister";
        int capacity = 8;
        double leakingRate = 0.001;
        int leftQuota = 5;
        Funnel funnel = funnels.get(userId);
        if (funnel == null) {
            funnel = new Funnel(capacity, leakingRate, leftQuota, System.currentTimeMillis());
        }
        //每1000ms(1s)，流入1的水
        //每1000ms，流出1000*leakingRate(而且要>1)的水
        for (int i = 0; i < 8; i++) {
            Boolean isBoolean = funnel.water(1);
            TimeUnit.MILLISECONDS.sleep(1000);
            System.out.println(isBoolean + " " + funnel.leftQuota);
        }

    }

}