Java限流策略

概要

在大数据量高并发访问时，经常会出现服务或接口面对暴涨的请求而不可用的情况，甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流，当请求达到一定的并发数或速率，就进行等待、排队、降级、拒绝服务等。在限流时，常见的两种算法是漏桶和令牌桶算法算法。

限流算法

令牌桶(Token Bucket)、漏桶(leaky bucket)和计数器算法是最常用的三种限流的算法。

1. 令牌桶算法

令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。 当桶满时，新添加的令牌被丢弃或拒绝。

令牌桶算法示例：

public class RateLimiterDemo {

    private static RateLimiter limiter = RateLimiter.create(5);

 

    public static void exec() {

        limiter.acquire(1);

        try {

            // 处理核心逻辑

            TimeUnit.SECONDS.sleep(1);

            System.out.println("--" + System.currentTimeMillis() / 1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

 

Guava RateLimiter 提供了令牌桶算法可用于平滑突发限流策略。
该示例为每秒中产生5个令牌，每200毫秒会产生一个令牌。
limiter.acquire() 表示消费一个令牌。当桶中有足够的令牌时，则直接返回0，否则阻塞，直到有可用的令牌数才返回，返回的值为阻塞的时间。

2. 漏桶算法

它的主要目的是控制数据注入到网络的速率，平滑网络上的突发流量，数据可以以任意速度流入到漏桶中。漏桶算法提供了一种机制，通过它，突发流量可以被整形以便为网络提供一个稳定的流量。 漏桶可以看作是一个带有常量服务时间的单服务器队列，如果漏桶为空，则不需要流出水滴，如果漏桶（包缓存）溢出，那么水滴会被溢出丢弃。

3. 计数器限流算法

计数器限流算法也是比较常用的，主要用来限制总并发数，比如数据库连接池大小、线程池大小、程序访问并发数等都是使用计数器算法。

使用计数器限流示例1：

public class CountRateLimiterDemo1 {

 

    private static AtomicInteger count = new AtomicInteger(0);

 

    public static void exec() {

        if (count.get() >= 5) {

            System.out.println("请求用户过多，请稍后在试！"+System.currentTimeMillis()/1000);

        } else {

            count.incrementAndGet();

            try {

                //处理核心逻辑

                TimeUnit.SECONDS.sleep(1);

                System.out.println("--"+System.currentTimeMillis()/1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            } finally {

                count.decrementAndGet();

            }

        }

    }

}

使用AomicInteger来进行统计当前正在并发执行的次数，如果超过域值就简单粗暴的直接响应给用户，说明系统繁忙，请稍后再试或其它跟业务相关的信息。

弊端：使用 AomicInteger 简单粗暴超过域值就拒绝请求，可能只是瞬时的请求量高，也会拒绝请求。

使用计数器限流示例2:

public class CountRateLimiterDemo2 {

 

    private static Semaphore semphore = new Semaphore(5);

 

    public static void exec() {

        if(semphore.getQueueLength()>100){

            System.out.println("当前等待排队的任务数大于100，请稍候再试...");

        }

        try {

            semphore.acquire();

            // 处理核心逻辑

            TimeUnit.SECONDS.sleep(1);

            System.out.println("--" + System.currentTimeMillis() / 1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            semphore.release();

        }

    }

}

使用Semaphore信号量来控制并发执行的次数，如果超过域值信号量，则进入阻塞队列中排队等待获取信号量进行执行。如果阻塞队列中排队的请求过多超出系统处理能力，则可以在拒绝请求。

相对Atomic优点：如果是瞬时的高并发，可以使请求在阻塞队列中排队，而不是马上拒绝请求，从而达到一个流量削峰的目的。

Semphore信号量的使用

前言：在多线程环境的同步中，我们为了让每个线程具有同步的作用，经常采用synchronize、reetrantlock等同步手段进行上锁，以便在同一时间只能有一个线程具有访问变量和读写变量的权力。然而假如实际的业务场景是允许一组线程访问（组线程数量有限），如何控制一组线程的同步，如果再采取加锁的方法就有点过犹不及了。那么此时信号量就闪亮登场了，对于一组线程的同步访问，对它来说就是小菜一碟

本篇博客的目录

一：semphore的简介

二：semphore的使用方法

三：使用实例

四：总结

一：semphore的简介

1.1:概念

semphpore是jdk提供的一个并发工具类，它位于java.util.concurrent包下，在jdk中对它是这样定义的：

     一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动，Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。简单解释一下这段概念：它就是说semphpore可以对一组线程进行限定，线程每次访问程序之前必须通过它的acquire()方法进入一个房间，也就是没有调用 acquire()方法，线程是无法读取程序的，然后再通过release()方法释放这个线程，其他线程后面才能进入,而它是否允许是通过计数来完成的。

1,.2:理解

举个通俗的例子,假如我们要从出发地A到目的地B,有一辆车,它只能容纳4个人，而我们一共有10个人要从A到B,这辆车就好比是资源，而人乘车这一行为就是线程访问资源，我们进入车需要车票，车票就可以理解为信号量，一次只能进入4个人，其他人只能等待（线程wait，处于阻塞状态），而到了目的地或者有人中途下车了，此时就是release()，释放信号量，那么等待的人才会获得允许上车，每次进入的时候，都会进行计数。

二：semphore的使用方法

2.1：acquire()方法

acquire()            从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

 

acquire(int permits)            从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被中断。

 acquire方法提供了两种不同的参数用来重载，它主要用于来控制线程是否允许从阻塞状态到活动状态，有点类似于进入高速公路前的“通行证”，只有调用了这个方法，线程才能从阻塞状态变为被唤醒。而acquire(int permits),则提供了指定数量的线程数用来允许此信号量获取一次进入的数量，这个方法比较常用，它经常被用于控制一组线程进行访问资源

2.2：release()方法

	release()            释放一个许可，将其返回给信号量。
	release(int permits)            释放给定数目的许可，将其返回到信号量。

 release方法和acquire方法相对应，通acquire方法获取了通行证，那么当使用完资源的时候，出去的时候就要调用release方法进行释放锁，这样其他线程才有资格再调用acquire方法再次获取"通行证”。同样它提供了重载的方法可以允许一次释放很多线程。

三：使用实例

3.1：现在来模拟10个人乘车，一辆车只能容纳4个人，所以一次只能进入4个人，而其他人只能处于阻塞状态，只有获取许可，才能进入车中，当一个人下来的时候其他人才能进入继续乘车

3.2：程序实例

3.2.1：我们先来模拟一个人，定义它的行为乘车和下车，比较简单，下面给出示例代码：

public class Person {

    private static final String suffix="号开始乘车";

    private static final String suffix2="号出来了";

    /**
     * 编号
     */
    private Integer no;

    public Person(Integer no) {
        this.no = no;
    }

    public void riding(){

        StringBuilder stringBuilder = new StringBuilder();

        System.out.println(stringBuilder.append(this.getNo()).append(suffix));

    }

    public void out(){

        StringBuilder stringBuilder = new StringBuilder();

        System.out.println(stringBuilder.append(this.getNo()).append(suffix2));

    }


    public Integer getNo() {
        return no;
    }

    public void setNo(Integer no) {
        this.no = no;
    }
}

3.2.2：再来定义一个乘车的线程,拥有信号量和人两个引用：

public class RideThread implements Runnable {

    private Semaphore semp;

    private Person person;

    public RideThread(Semaphore semp, Person person) {
        this.semp = semp;
        this.person = person;
    }

    public void run() {

        try {

            // 获取许可
            semp.acquire();

            person.riding();

            Thread.sleep((long) (Math.random() * 10000));

            person.out();
            // 访问完后，释放
            semp.release();


        } catch (InterruptedException e) {

            e.printStackTrace();

        }
    };
}

3.2.3：测试类

public class SemphoreTest {

    public static final Integer personNums=10;

    public static void main(String[] args) {
        // 线程池
        ExecutorService exec = Executors.newCachedThreadPool();

        // 只能4个人能同时上车
        final Semaphore semp = new Semaphore(4);

        // 模拟10个人乘车
        for (int index = 0; index < personNums; index++) {

            final int NO = index;

            Person person = new Person(NO);

            exec.submit(new RideThread(semp,person));

        }

        System.out.println(semp.isFair());

        // 退出线程池

        exec.shutdown();
    }
}

3.3：输出结果

"D:\Java\jdk 1.8.0_1\bin\java" -Didea.launcher.port=7532 "-Didea.launcher.bin.path=D:\IntelliJ IDEA 2016.3.4\bin" -Dfile.encoding=GBK -classpath "D:\Java\jdk 1.8.0_1\jre\lib\charsets.jar;D:\Java\jdk 1.8.0_1\jre\lib\deploy.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\access-bridge-32.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\cldrdata.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\dnsns.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\jaccess.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\jfxrt.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\localedata.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\nashorn.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\sunec.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\sunjce_provider.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\sunmscapi.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\sunpkcs11.jar;D:\Java\jdk 1.8.0_1\jre\lib\ext\zipfs.jar;D:\Java\jdk 1.8.0_1\jre\lib\javaws.jar;D:\Java\jdk 1.8.0_1\jre\lib\jce.jar;D:\Java\jdk 1.8.0_1\jre\lib\jfr.jar;D:\Java\jdk 1.8.0_1\jre\lib\jfxswt.jar;D:\Java\jdk 1.8.0_1\jre\lib\jsse.jar;D:\Java\jdk 1.8.0_1\jre\lib\management-agent.jar;D:\Java\jdk 1.8.0_1\jre\lib\plugin.jar;D:\Java\jdk 1.8.0_1\jre\lib\resources.jar;D:\Java\jdk 1.8.0_1\jre\lib\rt.jar;E:\Elas Search\Test\out\production\Test;D:\IntelliJ IDEA 2016.3.4\lib\idea_rt.jar" com.intellij.rt.execution.application.AppMain Semphore.SemphoreTest
1号开始乘车
0号开始乘车
3号开始乘车
2号开始乘车
false
3号出来了
4号开始乘车
2号出来了
5号开始乘车
4号出来了
6号开始乘车
5号出来了
7号开始乘车
1号出来了
8号开始乘车
8号出来了
9号开始乘车
7号出来了
0号出来了
6号出来了
9号出来了

可以看出来最开始先进入4个人乘车，首先4个人获取了许可证，然后后面的都是一个出来，另一个进去，只有当一个线程获取信号量再释放信号量的时候,其它线程才能乘车。这样按照顺序，严格限定每次只有空位的时候其他线程才能访问资源！观察结果，会发现最开始的4个是杂序的(后面进入的顺序是for循环控制的)，这是“非公平的”，因为在构造Semphore的时候，没有限定第二个参数isFair,这样默认是非公平的，符合按照顺序来进行线程的访问，假如要公平的话，我们可以指定第二个参数为true,这样构造出来的Semhore就是公平的，很多线程去抢，谁抢到是谁的，我们把第二个参数设置为true来观察一下输出的结果：

是否是公平锁:true
0号开始乘车
1号开始乘车
2号开始乘车
3号开始乘车

执行了很多次，都可以看出来最开始的线程是按照顺序进行的，这就是公平信号量，严格遵守顺序依次执行！

四：总结

      本篇博客讲述了Semphore的使用方法，只是抛砖引玉简单的阐述了几个重要的方法和基本使用，在实际的开发中，会遇到更加复杂的业务场景，如何选择jdk提供给我们的便捷的开发工具，在并发中做到没有脏数据，高效、稳定是我们每个开发者都将追求的目标。

转自：https://www.cnblogs.com/java1024/p/7725632.html、https://www.cnblogs.com/wyq178/p/9611075.html