Semaphore的使用并实现的限流器

semaphore 基本原理

semaphore 翻译成字面意思是信号量，Semaphore可以控制同时访问的线程个数，通过acquire（）获取一个许可，如果没有就等待，而release()释放一个许可。
从功能看semaphore的底层是基于AQS实现的一个共享锁，需要多个现场共享一个令牌池。创建semaphore实例的时候，需要一个参数permits，这个基本可以确定是设置给AQS的state的，然后每一个线程调用的acquire的时候，执行state = state-1，release的时候执行state = state +1，当然，如果state = 0 了，说明没有资源了，需要等待其他线程release。

Semaphore类位于java.util.concurrent包下，提供了2个构造器

    public Semaphore(int permits) {
    // 参数permits表示许可数目，可以多少个线程同时访问
        sync = new NonfairSync(permits);
    }
    public Semaphore(int permits, boolean fair) { 
    // 这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

下面说一下Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

下面通过一个例子来看一下Semaphore的具体使用：
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {

    public static void main(String[] args){

        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss SSS");

        final Semaphore semaphore = new Semaphore(5);

        for(int i = 0;i<8;i++){

            // 定义8个线程

            new Thread("工人"+i){
                @Override
                public void run() {

                    try {
                        semaphore.acquire();

                        System.out.println(sdf.format(new Date()) + "   " + Thread.currentThread().getName() +"获得一个许可，并开始执行任务");
                        Thread.sleep(3000);
                        System.out.println(sdf.format(new Date()) + "   " + Thread.currentThread().getName() +"执行完毕，开始释放许可");
                        semaphore.release();

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }
    }
}

执行结果：

实现一个简单的限流器

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;


public class SemaphoreLimitTest {

    // 定义一个执行线程池
    private final Executor executor = new ThreadPoolExecutor(10, 20, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(10));
    // 每次只能执行5个任务
    final Semaphore semaphore = new Semaphore(5);

    public void process() {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss SSS");
                try {
                    semaphore.acquire();
                    System.out.println(sdf.format(new Date()) + "   " + Thread.currentThread().getName() + "获得一个许可，并开始执行任务");
                    Thread.sleep(3000);
                    System.out.println(sdf.format(new Date()) + "   " + Thread.currentThread().getName() + "执行完毕，开始释放许可");
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }


    // 模拟测试
    public static void main(String[] args) {
        final SemaphoreLimitTest semaphoreLimitTest = new SemaphoreLimitTest();
        // 同时进来8个任务
        for (int i = 0; i < 8; i++) {
            // 定义8个线程
            new Thread("线程" + i) {
                @Override
                public void run() {
                    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss SSS");
                    System.out.println(sdf.format(new Date()) + "   " + Thread.currentThread().getName() + "开始请求");
                    semaphoreLimitTest.process();
                }
            }.start();
        }
    }

}