SpringCloud Alibaba系列——14Sentinel简介及基本应用(（上）

public class BlockException extends Exception {}
1.

public interface RateLimit {    boolean canPass() throws BlockException;}
1.

/** * CounterRateLimit * 计算器限流 * */public class CounterRateLimit implements RateLimit , Runnable {    /**     * 阈值     */    private Integer limitCount;    /**     * 当前通过请求数     */    private AtomicInteger passCount;    /**     * 统计时间间隔     */    private long period;    private TimeUnit timeUnit;    private ScheduledExecutorService scheduledExecutorService;     public CounterRateLimit(Integer limitCount) {        this(limitCount, 1000, TimeUnit.MILLISECONDS);    }     public CounterRateLimit(Integer limitCount, long period, TimeUnit timeUnit) {        this.limitCount = limitCount;        this.period = period;        this.timeUnit = timeUnit;        passCount = new AtomicInteger(1);        this.startResetTask();    }     @Override    public boolean canPass() throws BlockException {        if (passCount.incrementAndGet() > limitCount) {            throw new BlockException();        }        return true;    }     private void startResetTask() {        scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();        scheduledExecutorService.scheduleAtFixedRate(this, 0, period, timeUnit);    }     @Override    public void run() {        passCount.set(1);    }     public static void main(String[] args) throws BlockException, InterruptedException {        CounterRateLimit counterRateLimit = new CounterRateLimit(10, 2000, TimeUnit.MILLISECONDS);        for (int i = 1; i < 10000000; i++) {            Thread.sleep(200);            if (counterRateLimit.canPass()) {                System.out.println("我是第" + i + "个请求");            }        }    }}
1.

/** * SlidingWindowRateLimit * 滑动窗口限流 */@Slf4jpublic class SlidingWindowRateLimit implements RateLimit, Runnable {     /**     * 阈值     */    private Integer limitCount;     /**     * 当前通过的请求数     */    private AtomicInteger passCount;     /**     * 窗口数     */    private Integer windowSize;     /**     * 每个窗口时间间隔大小     */    private long windowPeriod;    private TimeUnit timeUnit;      private Window[] windows;    private volatile Integer windowIndex = 0;     private Lock lock = new ReentrantLock();    public SlidingWindowRateLimit(Integer limitCount) {        // 默认统计qps, 窗口大小5        this(limitCount, 5, 200, TimeUnit.MILLISECONDS);    }     /**     * 统计总时间 = windowSize * windowPeriod     */    public SlidingWindowRateLimit(Integer limitCount, Integer windowSize, Integer windowPeriod, TimeUnit timeUnit) {        this.limitCount = limitCount;        this.windowSize = windowSize;        this.windowPeriod = windowPeriod;        this.timeUnit = timeUnit;        this.passCount = new AtomicInteger(0);        this.initWindows(windowSize);        this.startResetTask();    }     @Override    public boolean canPass() throws BlockException {        lock.lock();        if (passCount.get() > limitCount) {            throw new BlockException();        }        windows[windowIndex].passCount.incrementAndGet();        passCount.incrementAndGet();        lock.unlock();        return true;    }     private void initWindows(Integer windowSize) {        windows = new Window[windowSize];        for (int i = 0; i < windowSize; i++) {            windows[i] = new Window();        }    }     private ScheduledExecutorService scheduledExecutorService;    private void startResetTask() {        scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();        scheduledExecutorService.scheduleAtFixedRate(this, windowPeriod, windowPeriod, timeUnit);    }     @Override    public void run() {        // 获取当前窗口索引        Integer curIndex = (windowIndex + 1) % windowSize;//        log.info("curIndex = {}", curIndex);        // 重置当前窗口索引通过数量，并获取上一次通过数量        Integer count = windows[curIndex].passCount.getAndSet(0);        windowIndex = curIndex;        // 总通过数量 减去 当前窗口上次通过数量        passCount.addAndGet(-count);//        log.info("curOldCount = {}, passCount = {}, windows = {}", count, passCount, windows);    }     @Data    class Window {        private AtomicInteger passCount;        public Window() {            this.passCount = new AtomicInteger(0);        }    }     public static void main(String[] args) throws BlockException, InterruptedException {        SlidingWindowRateLimit slidingWindowRateLimit = new SlidingWindowRateLimit(100);        for(int i=1;i<10000000;i++){//            Thread.sleep(10);            if(slidingWindowRateLimit.canPass()){                System.out.println("我是第"+i+"个请求");            }        }     }}
1.

/** * LeakyBucketRateLimit * 漏桶算法 */@Slf4jpublic class LeakyBucketRateLimit implements RateLimit, Runnable {     /**     * 出口限制qps     */    private Integer limitSecond;    /**     * 漏桶队列     */    private BlockingQueue<Thread> leakyBucket;     private ScheduledExecutorService scheduledExecutorService;     public LeakyBucketRateLimit(Integer bucketSize, Integer limitSecond) {        this.limitSecond = limitSecond;        this.leakyBucket = new LinkedBlockingDeque<>(bucketSize);         scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();        long interval = (1000 * 1000 * 1000) / limitSecond;//周期秒。TimeUnit.NANOSECONDS（毫微秒，1秒=1000*1000*1000毫微秒        scheduledExecutorService.scheduleAtFixedRate(this, 0, interval, TimeUnit.NANOSECONDS);    }     @Override    public boolean canPass() throws BlockException {        if (leakyBucket.remainingCapacity() == 0) {            throw new BlockException();        }        leakyBucket.offer(Thread.currentThread());        LockSupport.park();        return true;    }     @Override    public void run() {        Thread thread = leakyBucket.poll();        if (Objects.nonNull(thread)) {            LockSupport.unpark(thread);        }    }    public static void main(String[] args) throws BlockException, InterruptedException {        LeakyBucketRateLimit leakyBucketRateLimit = new LeakyBucketRateLimit(100,10);        for(int i=1;i<10000000;i++){            if(leakyBucketRateLimit.canPass()){                System.out.println("我是第"+i+"个请求");            }        }    }}
1.

/** * TokenBucketRateLimit * 令牌桶 */@Slf4jpublic class TokenBucketRateLimit implements RateLimit, Runnable {     /**     * token 生成 速率 （每秒）     */    private Integer tokenLimitSecond;     /**     * 令牌桶队列     */    private BlockingQueue<String /* token */> tokenBucket;     private static final String TOKEN = "__token__";     private ScheduledExecutorService scheduledExecutorService;     public TokenBucketRateLimit(Integer bucketSize, Integer tokenLimitSecond) {        this.tokenLimitSecond = tokenLimitSecond;        this.tokenBucket = new LinkedBlockingDeque<>(bucketSize);         scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();        long interval = (1000 * 1000 * 1000) / tokenLimitSecond;        scheduledExecutorService.scheduleAtFixedRate(this, 0, interval, TimeUnit.NANOSECONDS);    }     @Override    public boolean canPass() throws BlockException {        String token = tokenBucket.poll();        if (StringUtils.isEmpty(token)) {            throw new BlockException();        }        return true;    }    @Override    public void run() {        if (tokenBucket.remainingCapacity() == 0) {            return;        }        tokenBucket.offer(TOKEN);    }}
1.

<dependency>    <groupId>com.google.guava</groupId>    <artifactId>guava</artifactId>    <version>22.0</version></dependency>
1.

public class RateLimiterDemo {    private static final SimpleDateFormat FORMATTER = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    //线程数    private static final int THREAD_COUNT = 25;     public static void main(String[] args) {        RateLimiterDemo rateLimiterDemo = new RateLimiterDemo();        rateLimiterDemo.testRateLimiter1();    }     public void testRateLimiter1() {        //令牌桶算法        RateLimiter rateLimiter=RateLimiter.create(1); //TPS=1        Thread[] ts = new Thread[THREAD_COUNT];        for (int i = 0; i < THREAD_COUNT; i++) {            ts[i] = new Thread(new RateLimiterThread(rateLimiter), "RateLimiterThread-" + i);        }        for (int i = 0; i < THREAD_COUNT; i++) {            ts[i].start();        }        for(;;) {        }    }     public class RateLimiterThread implements Runnable {        private RateLimiter rateLimiter;        public RateLimiterThread(RateLimiter rateLimiter) {            this.rateLimiter = rateLimiter;        }        @Override        public void run() {            rateLimiter.acquire(1);            System.out.println(Thread.currentThread().getName() + "获取到了令牌，时间 = " + FORMATTER.format(new Date()));        }    }}
1.