java限流器_Semaphore：如何快速实现一个限流器？

信号量模型

信号量模型还是很简单的，可以简单概括为：一个计数器，一个等待队列，三个方法。在信号量模型里，计数器和等待队列对外是透明的，所以只能通过信号量模型提供的三个方法来访问它们，这三个方法分别是：init()、down() 和 up()。你可以结合下图来形象化地理解。

这三个方法详细的语义具体如下所示。init()：设置计数器的初始值。

down()：计数器的值减 1；如果此时计数器的值小于 0，则当前线程将被阻塞，否则当前线程可以继续执行。

up()：计数器的值加 1；如果此时计数器的值小于或者等于 0，则唤醒等待队列中的一个线程，并将其从等待队列中移除

这里提到的 init()、down() 和 up() 三个方法都是原子性的，并且这个原子性是由信号量模型的实现方保证的。在 Java SDK 里面，信号量模型是由 java.util.concurrent.Semaphore 实现的，Semaphore 这个类能够保证这三个方法都是原子操作。

如果你觉得上面的描述有点绕的话，可以参考下面这个代码化的信号量模型。

public class Semaphore{

// 计数器

int count;

// 等待队列

Queue queue;

// 初始化操作

Semaphore(int c){

this.count=c;

}

//

void down(){

this.count--;

if(this.count<0){

//将当前线程插入等待队列

//阻塞当前线程

}

}

void up(){

this.count++;

if(this.count<=0) {

//移除等待队列中的某个线程T

//唤醒线程T

}

}

}

这里再插一句，信号量模型里面，down()、up() 这两个操作历史上最早称为 P 操作和 V 操作，所以信号量模型也被称为 PV 原语。另外，还有些人喜欢用 semWait() 和 semSignal() 来称呼它们，虽然叫法不同，但是语义都是相同的。在 Java SDK 并发包里，down() 和 up() 对应的则是 acquire() 和 release()。

如何使用信号量

通过上文，你应该会发现信号量的模型还是很简单的，那具体该如何使用呢？其实你想想红绿灯就可以了。十字路口的红绿灯可以控制交通，得益于它的一个关键规则：车辆在通过路口前必须先检查是否是绿灯，只有绿灯才能通行。这个规则和我们前面提到的锁规则是不是很类似？

其实，信号量的使用也是类似的。这里我们还是用累加器的例子来说明信号量的使用吧。在累加器的例子里面，count+=1 操作是个临界区，只允许一个线程执行，也就是说要保证互斥。那这种情况用信号量怎么控制呢？

其实很简单，就像我们用互斥锁一样，只需要在进入临界区之前执行一下 down() 操作，退出临界区之前执行一下 up() 操作就可以了。下面是 Java 代码的示例，acquire() 就是信号量里的 down() 操作，release() 就是信号量里的 up() 操作

static int count;

//初始化信号量

static final Semaphore s

= new Semaphore(1);

//用信号量保证互斥

static void addOne(){

s.acquire();

try {

count+=1;

} finally {

s.release();

}

}

快速实现一个限流器

上面的例子，用信号量实现了一个最简单的互斥锁功能。估计你会觉得奇怪，既然有 Java SDK 里面提供了 Lock，为啥还要提供一个 Semaphore ？其实实现一个互斥锁，仅仅是 Semaphore 的部分功能，Semaphore 还有一个功能是 Lock 不容易实现的，那就是：Semaphore 可以允许多个线程访问一个临界区。

现实中还有这种需求？有的。比较常见的需求就是我们工作中遇到的各种池化资源，例如连接池、对象池、线程池等等。其中，你可能最熟悉数据库连接池，在同一时刻，一定是允许多个线程同时使用连接池的，当然，每个连接在被释放前，是不允许其他线程使用的。

下面是一个对象池的创建和释放的示例代码

public class ObjPool{

final List pool;

// 用信号量实现限流器

final Semaphore sem;

// 构造函数

ObjPool(int size, T t){

pool = new Vector(){};

for(int i=0; i

pool.add(t);

}

sem = new Semaphore(size);

}

// 利用对象池的对象，调用func

R exec(Function func){

T t = null;

sem.acquire();

try {

t = pool.remove(0);

return func.apply(t);

} finally {

pool.add(t);

sem.release();

}

}

}

// 创建对象池

ObjPool pool =

new ObjPool(10, 2);

// 通过对象池获取t，之后执行

pool.exec(t -> {

System.out.println(t);

return t.toString();

});

用一个 List来保存对象实例，用 Semaphore 实现限流器。关键的代码是 ObjPool 里面的 exec() 方法，这个方法里面实现了限流的功能。在这个方法里面，我们首先调用 acquire() 方法(与之匹配的是在 finally 里面调用 release() 方法)，假设对象池的大小是 10，信号量的计数器初始化为 10，那么前 10 个线程调用 acquire() 方法，都能继续执行，相当于通过了信号灯，而其他线程则会阻塞在 acquire() 方法上。对于通过信号灯的线程，我们为每个线程分配了一个对象 t(这个分配工作是通过 pool.remove(0) 实现的)，分配完之后会执行一个回调函数 func，而函数的参数正是前面分配的对象 t ；执行完回调函数之后，它们就会释放对象(这个释放工作是通过 pool.add(t) 实现的)，同时调用 release() 方法来更新信号量的计数器。如果此时信号量里计数器的值小于等于 0，那么说明有线程在等待，此时会自动唤醒等待的线程

简言之，使用信号量，我们可以轻松地实现一个限流器，使用起来还是非常简单的

总结

信号量在 Java 语言里面名气并不算大，但是在其他语言里却是很有知名度的。Java 在并发编程领域走的很快，重点支持的还是管程模型。管程模型理论上解决了信号量模型的一些不足，主要体现在易用性和工程化方面，例如用信号量解决也可以解决我们日常的普通阻塞队列问题