package com.oldlu.limit;
import java.util.concurrent.*;
public class Counter {
    public static void main(String[] args) {
        //計(jì)數(shù)器，這里用信號(hào)量實(shí)現(xiàn)
        final Semaphore semaphore = new Semaphore(3);
        //定時(shí)器，到點(diǎn)清零
        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                semaphore.release(3);
            }
        },3000,3000,TimeUnit.MILLISECONDS);
        //模擬無(wú)數(shù)個(gè)請(qǐng)求從天而降
        while (true) {
            try {
                //判斷計(jì)數(shù)器
                semaphore.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //如果準(zhǔn)許響應(yīng)，打印一個(gè)ok
            System.out.println("ok");
        }
    }
}

package com.oldlu.limit;
import java.util.concurrent.*;
public class Barrel {
    public static void main(String[] args) {
        //桶，用阻塞隊(duì)列實(shí)現(xiàn)，容量為3
        final LinkedBlockingQueue<Integer> que = new LinkedBlockingQueue(3);
        //定時(shí)器，相當(dāng)于服務(wù)的窗口，2s處理一個(gè)
        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                int v = que.poll();
                System.out.println("處理："+v);
            }
        },2000,2000,TimeUnit.MILLISECONDS);
        //無(wú)數(shù)個(gè)請(qǐng)求，i 可以理解為請(qǐng)求的編號(hào)
        int i=0;
        while (true) {
            i++;
            try {
                System.out.println("put:"+i);
                //如果是put，會(huì)一直等待桶中有空閑位置，不會(huì)丟棄
//                que.put(i);
                //等待1s如果進(jìn)不了桶，就溢出丟棄
                que.offer(i,1000,TimeUnit.MILLISECONDS);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

http {
    #$binary_remote_addr 表示通過(guò)remote_addr這個(gè)標(biāo)識(shí)來(lái)做key，也就是限制同一客戶端ip地址。
#zone=one:10m 表示生成一個(gè)大小為10M，名字為one的內(nèi)存區(qū)域，用來(lái)存儲(chǔ)訪問(wèn)的頻次信息。    
#rate=1r/s 表示允許相同標(biāo)識(shí)的客戶端每秒1次訪問(wèn)    
    limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
    server {
        location /limited/ {
        #zone=one 與上面limit_req_zone 里的name對(duì)應(yīng)。
#burst=5 緩沖區(qū)，超過(guò)了訪問(wèn)頻次限制的請(qǐng)求可以先放到這個(gè)緩沖區(qū)內(nèi)，類似代碼中的隊(duì)列長(zhǎng)度。        
#nodelay 如果設(shè)置，超過(guò)訪問(wèn)頻次而且緩沖區(qū)也滿了的時(shí)候就會(huì)直接返回503，如果沒(méi)有設(shè)置，則所有請(qǐng)求
會(huì)等待排隊(duì)，類似代碼中的put還是offer。  
       
        limit_req zone=one burst=5 nodelay;
    }
}

package com.oldlu.limit;
import java.util.concurrent.*;
public class Token {
    public static void main(String[] args) throws InterruptedException {
        //令牌桶，信號(hào)量實(shí)現(xiàn)，容量為3
        final Semaphore semaphore = new Semaphore(3);
        //定時(shí)器，1s一個(gè)，勻速頒發(fā)令牌
        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                if (semaphore.availablePermits() < 3){
                    semaphore.release();
                }
//                System.out.println("令牌數(shù)："+semaphore.availablePermits());
            }
        },1000,1000,TimeUnit.MILLISECONDS);
        //等待，等候令牌桶儲(chǔ)存
        Thread.sleep(5);
        //模擬洪峰5個(gè)請(qǐng)求，前3個(gè)迅速響應(yīng)，后兩個(gè)排隊(duì)
        for (int i = 0; i < 5; i++) {
            semaphore.acquire();
            System.out.println("洪峰："+i);
        }
        //模擬日常請(qǐng)求，2s一個(gè)
        for (int i = 0; i < 3; i++) {
            Thread.sleep(1000);
            semaphore.acquire();
            System.out.println("日常："+i);
            Thread.sleep(1000);
        }
        //再次洪峰
        for (int i = 0; i < 5; i++) {
            semaphore.acquire();
            System.out.println("洪峰："+i);
        }
        //檢查令牌桶的數(shù)量
        for (int i = 0; i < 5; i++) {
            Thread.sleep(2000);
            System.out.println("令牌剩余："+semaphore.availablePermits());
        }
    }
}

cloud:
    gateway:
      routes:
      ‐ id: limit_route
        uri: http://localhost:8080/test
        filters:
        ‐ name: RequestRateLimiter
          args:
           #限流的key，ipKeyResolver為spring中托管的Bean，需要擴(kuò)展KeyResolver接口  
            key‐resolver: '#{@ipResolver}'
            #令牌桶每秒填充平均速率，相當(dāng)于代碼中的發(fā)放頻率
            redis‐rate‐limiter.replenishRate: 1
            #令牌桶總?cè)萘?，相?dāng)于代碼中，信號(hào)量的容量
            redis‐rate‐limiter.burstCapacity: 3

package com.oldlu.limit;
import java.util.LinkedList;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class Window {
    //整個(gè)窗口的流量上限，超出會(huì)被限流
    final int totalMax = 5;
    //每片的流量上限，超出同樣會(huì)被拒絕，可以設(shè)置不同的值
    final int sliceMax = 5;
    //分多少片
    final int slice = 3;
    //窗口，分3段，每段1s，也就是總長(zhǎng)度3s
    final LinkedList<Long> linkedList = new LinkedList<>();
    //計(jì)數(shù)器，每片一個(gè)key，可以使用HashMap，這里為了控制臺(tái)保持有序性和可讀性，采用TreeMap
    Map<Long,AtomicInteger> map = new TreeMap();
    //心跳，每1s跳動(dòng)1次，滑動(dòng)窗口向前滑動(dòng)一步，實(shí)際業(yè)務(wù)中可能需要手動(dòng)控制滑動(dòng)窗口的時(shí)機(jī)。
    ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
    //獲取key值，這里即是時(shí)間戳（秒）
    private Long getKey(){
        return System.currentTimeMillis()/1000;
    }
    public Window(){
        //初始化窗口，當(dāng)前時(shí)間指向的是最末端，前兩片其實(shí)是過(guò)去的2s
        Long key = getKey();
        for (int i = 0; i < slice; i++) {
            linkedList.addFirst(key‐i);
            map.put(key‐i,new AtomicInteger(0));
        }
        //啟動(dòng)心跳任務(wù)，窗口根據(jù)時(shí)間，自動(dòng)向前滑動(dòng)，每秒1步
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Long key = getKey();
                //隊(duì)尾添加最新的片
                linkedList.addLast(key);
                map.put(key,new AtomicInteger());
                //將最老的片移除
                map.remove(linkedList.getFirst());
                linkedList.removeFirst();
                System.out.println("step:"+key+":"+map);;
            }
        },1000,1000,TimeUnit.MILLISECONDS);
    }
    //檢查當(dāng)前時(shí)間所在的片是否達(dá)到上限
    public boolean checkCurrentSlice(){
        long key = getKey();
        AtomicInteger integer = map.get(key);
        if (integer != null){
            return integer.get() < sliceMax ;
        }
        //默認(rèn)允許訪問(wèn)
        return true;
    }
    //檢查整個(gè)窗口所有片的計(jì)數(shù)之和是否達(dá)到上限
    public boolean checkAllCount(){
        return map.values().stream().mapToInt(value ‐> value.get()).sum()  < totalMax;
    }
    //請(qǐng)求來(lái)臨....
    public void req(){
        Long key = getKey();
        //如果時(shí)間窗口未到達(dá)當(dāng)前時(shí)間片，稍微等待一下
        //其實(shí)是一個(gè)保護(hù)措施，放置心跳對(duì)滑動(dòng)窗口的推動(dòng)滯后于當(dāng)前請(qǐng)求
        while (linkedList.getLast()<key){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //開始檢查，如果未達(dá)到上限，返回ok，計(jì)數(shù)器增加1
        //如果任意一項(xiàng)達(dá)到上限，拒絕請(qǐng)求，達(dá)到限流的目的
        //這里是直接拒絕?，F(xiàn)實(shí)中可能會(huì)設(shè)置緩沖池，將請(qǐng)求放入緩沖隊(duì)列暫存
        if (checkCurrentSlice() && checkAllCount()){
            map.get(key).incrementAndGet();
            System.out.println(key+"=ok:"+map);
        }else {
            System.out.println(key+"=reject:"+map);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Window window = new Window();
        //模擬10個(gè)離散的請(qǐng)求，相對(duì)之間有200ms間隔。會(huì)造成總數(shù)達(dá)到上限而被限流
        for (int i = 0; i < 10; i++) {
            Thread.sleep(200);
            window.req();
        }
        //等待一下窗口滑動(dòng)，讓各個(gè)片的計(jì)數(shù)器都置零
        Thread.sleep(3000);
        //模擬突發(fā)請(qǐng)求，單個(gè)片的計(jì)數(shù)器達(dá)到上限而被限流
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
        for (int i = 0; i < 10; i++) {
        window.req();
        }
    }
}