Java并发工具类Semaphore

Posted 2021-03-09 myworld7

前言

1965年，荷兰计算机科学家Dijkstra提出的信号量机制成为一种高效的进程同步机制。这之后的15年，信号量一直都是并发编程领域的终结者。1980年，管程被提出，成为继信号量之后的在并发编程领域的第二个选择。目前几乎所有的语言都支持信号量机制，Java也不例外。Java中提供了Semaphore并发工具类来支持信号量机制。下面我们就来了解Java实现的信号量机制。
首先介绍信号量模型，然后介绍如何使用，最后使用信号量来实现一个限流器。

信号量模型

信号量模型图（图来自参考[1]）：

信号量模型总结为：一个计数器、一个等待队列和三个对外调用的方法。
计数器和等待队列时对外透明的，所有我们只能通过三个对外方法来访问计数器和等待队列。
init()：设置计数器的初始值。
down()：计数器的值减一。如果此时计数器的值小于0，则当前线程插入等待队列并阻塞，否则当前线程可以继续执行。
up()：计数器的值加一。如果此时计数器的值小于或者等于0，则唤醒等待队列中的一个线程，并将其从等待队列中移除。

这三个方法都是原子性的，由实现信号量模型的方法保证。在Java SDK中，信号量模型是由java.util.concurrent.Semaphore实现。

信号量模型代码化大致类似如下：

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操作（荷兰语proberen，测试）和V操作（荷荷兰语verhogen，增加）。在我学的操作系统教材中（C语言实现），P操作对应wait()，V操作对应singal()。虽然叫法不同，但是语义都是相同的。在Java SDK并发包中，down()和up()分别对应于Semaphore中的acquire()和release()。

如何使用信号量

信号量有时也被称为红绿灯，我们想想红绿灯时怎么控制交通的，就知道该如何使用信号量。车辆路过十字路时，需要先检查是否为绿灯，如果是则通行，否则就等待。想想和加锁机制有点相似，都是一样的操作，先检查是否符合条件（“尝试获取”），符合（“获取到”）则线程继续运行，否则阻塞线程。

下面使用累加器的例子来说明如何使用信号量。

count+=1操作是个临界区，只允许一个线程执行，即要保证互斥。于是我们在进入临界区之前，使用down()即Java中的acquire()，在退出之后使用up()即Java中的release()。

static int count;
//初始化信号量
static final Semaphore s = new Semaphore(1); // 构造函数参数为1，表示只允许一个线程进行临界区。可实现一个互斥锁的功能。
//用信号量保证互斥    
static void addOne() {
    s.acquire(); // 获取一个许可(可看作加锁机制中加锁)
    try {
        count+=1;
    } finally {
        s.release(); // 归还许可(可看做加锁机制中解锁)
    }
}

完整代码如下:

package com.sakura.concrrent;
import java.util.concurrent.Semaphore;
public class SemaphoreTest {
    static int count;
    static final Semaphore s = new Semaphore(1);
    static void addOne() throws InterruptedException {
        //只会有一个线程将信号量中的计数器减为1，而另外一个线程只能将信号量中计数器减为-1，导致被阻塞
        s.acquire();??
        try {
            count +=1;
            System.out.println("Now thread is " + Thread.currentThread() + "???and count is " + count);
        }finally {
            //进入临界区的线程在执行完临界区代码后将信号量中计数器的值加1然后，此时信号量中计数器的值为0，则从阻塞队列中唤醒被阻塞的进程
            s.release();???
        }
    }

    public static void main(String[] args) {
        // 创建两个线程运行
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start();
        thread2.start();
        System.out.println("main thread");

    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i=0; i<10; i++) {???????????????????
            try {
                SemaphoreTest.addOne();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

如果Semaphore的构造函数参数（许可数量，内置计数器的值）修改一下：

static final Semaphore s = new Semaphore(2);

则计数器值的为2，那么就允许有两个线程进入临界区，我们的count值就会出现问题

快速实现一个限流器

当设置信号量的计数器为1时，可实现一个简单的互斥锁功能。但是，我们前面刚介绍过Java SDK中的Lock，Semaphore的用途显然不会与Lock一致，不然就重复造轮子了。Semaphore最重要的一个功能便是：可以允许多个线程访问一个临界区。（上述例子我们就设置了计数器的值为2，可发现thread1和thread2都可进入临界区。）

我们会在什么地方遇见这种需求呢？
各种池化资源，例如连接池、对象池、线程池等等。例如，数据库连接池，在同一时刻，一定是允许多个线程同时使用连接池，当然，每个连接在被释放之前，是不允许其他线程使用的。

我们设计如下可以允许N个线程使用的对象池，我们将信号量的计数器值设为N，就可以让N个线程同时进行临界区，多余的就会被阻塞。（代码来自参考[1]）

class ObjPool<T, R> {
    final List<T> pool;? ? //使用List保存实例对象
    // 用信号量实现限流器
    final Semaphore sem;
    
    // 构造函数
    ObjPool(int size, T t){
        pool = new Vector<T>(){}; 
        for(int i=0; i<size; i++){
            pool.add(t);
        }
        sem = new Semaphore(size);
    }
    
    // 获取对象池的对象，调用 func
    R exec(Function<T,R> func) {
        T t = null;
        sem.acquire();? ? //允许N个进程同时进入临界区
        try {
            //我们需要注意，因为多个进行可以进入临界区，所以Vector的remove方法是线程安全的
            t = pool.remove(0);? ??
            return func.apply(t);? ? //获取对象池汇中的一个对象后，调用func函数
        } finally {
            pool.add(t);? ? //离开临界区之前，将之前获取的对象放回到池中
            sem.release();? ? //使得计数器加1，如果信号量中计数器小于等于0，那么说明有线程在等待，此时就会自动唤醒等待线程
        }
    }
}
// 创建对象池
ObjPool<Long, String> pool = new ObjPool<Long, String>(10, 2);

// 通过对象池获取 t，之后执行??
pool.exec(t -> {
    System.out.println(t);
    return t.toString();
});

小结

记得学习操作系统时，信号量类型分为了好几种整型信号量、记录型信号量、AND信号量以及“信号量集”（具体了解可戳参考[2]）。我认为Java SDK中Semaphore应该是记录型信号量的实现。不由想起，编程语言是对OS层面操作的一种抽象描述。这句话需要品需要细细品。

参考：
[1] 极客时间专栏王宝令《Java并发编程实战》
[2] 静水深流.操作系统之信号量机制总结.https://www.cnblogs.com/IamJiangXiaoKun/p/9464336.html