java实现流量控制

有些时候我们的服务负载有限，这时候就需要限制对其的并发访问，常见的应用场景是开放api。下面介绍两种流量控制的方式。

1.信号量semaphore

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

获得一项前，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，将项返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用 acquire() 时无法保持同步锁，因为这会阻止将项返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。

将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，二进制信号量具有某种属性（与很多 Lock 实现不同），即可以由线程释放“锁”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。

此类的构造方法可选地接受一个公平参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入是允许的，也就是说可以在已经等待的线程前为调用 acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用获取方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了 acquire，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的 tryAcquire 方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

此类还提供便捷的方法来同时 acquire 和释放多个许可。小心，在未将公平设置为 true 时使用这些方法会增加不确定延期的风险。

内存一致性效果：线程中调用“释放”方法（比如 release()）之前的操作 happen-before 另一线程中紧跟在成功的“获取”方法（比如 acquire()）之后的操作。

上面说了这么多来看看如何应用：
用信号量实现对一个方法的并发访问，每次只能10个线程同时访问，超过线程数直接返回，代码如下：

private static Semaphore semaphore = new Semaphore(10);

    void toDo() {
        if (!semaphore.tryAcquire()) {
            return;
        }
        try {
            //do something
        } finally {
            semaphore.release();
        }
    }

2. 并发计数器

也可以使用并发计数器来实现，设置一个计数器，当小于限制放行，进入后当前计数+1，结束后当前计数-1

private static AtomicInteger atomicInteger = new AtomicInteger(1);

    void toAdd() {
        int count = atomicInteger.get();
        if (count > 10) {
            return;
        }
        if (!atomicInteger.compareAndSet(count, count + 1)) {
            return;
        }
        //do something
        atomicInteger.decrementAndGet();
    }

注意上面的if (count > 10) 不能使用atomicInteger.getAndDecrement()>10，atomicInteger.getAndDecrement()虽然是原子操作，但是atomicInteger.getAndDecrement()>10却不是原子操作，在进行比较那一刻，可能有其它线程已经更改了atomicInteger值。

3. 测试

下面对上面的两种方法进行测试，看看能否达到效果，测试代码如下：

public class FlowControl {

    private static Semaphore semaphore = new Semaphore(10);

    void toDo() {
        if (!semaphore.tryAcquire()) {
            return;
        }
        try {
        	//---------------------------do something-----------------------
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //---------------------------------------------------------------------
        } finally {
            semaphore.release();
        }
    }

    private static AtomicInteger atomicInteger = new AtomicInteger(1);

    void toAdd() {
        int count = atomicInteger.get();
        if (count > 10) {
            return;
        }
        if (!atomicInteger.compareAndSet(count, count + 1)) {
            return;
        }
        //---------------------------do something-----------------------
		System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //---------------------------------------------------------------------
        atomicInteger.decrementAndGet();
    }

    public static void main(String[] args) {
        final FlowControl f = new FlowControl();
        for (int i = 0; i < 10; i++) {
            Thread[] threads = new Thread[20];
            for (int j = 0; j < 20; j++) {
                Thread t = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        f.toDo();
                    }
                });
                threads[j] = t;
                t.start();
            }
            for (int j = 0; j < 20; j++) {
                try {
                    threads[j].join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("-----------------");
        }
    }
}

测试代码启动20个线程每次对方法调用，共循环10次。输出结果如下：
可以看到每次只能有10个线程能够同时访问，达到了流量控制目的

Thread-0
Thread-1
Thread-2
Thread-3
Thread-4
Thread-5
Thread-6
Thread-7
Thread-8
Thread-9
-----------------
Thread-20
Thread-21
Thread-22
Thread-23
Thread-24
Thread-25
Thread-26
Thread-27
Thread-28
Thread-30
-----------------
Thread-40
Thread-42
Thread-41
Thread-43
Thread-44
Thread-45
Thread-46
Thread-47
Thread-48
Thread-49
-----------------