Java并发编程之Semaphore

Java并发编程之Semaphore

**Semaphore简介：**在多线程环境下用于协调各个线程, 以保证它们能够正确、合理的使用公共资源。信号量维护了一个许可集，我们在初始化Semaphore时需要为这个许可集传入一个数量值，该数量值代表同一时间能访问共享资源的线程数量。线程可以通过acquire()方法获取到一个许可，然后对共享资源进行操作，如果许可集已分配完了，那么线程将进入等待状态，直到其他线程释放许可后等待的线程才有机会再获取许可，线程释放一个许可通过release()方法完成。Semaphore 跟锁（synchronized、Lock）有点相似，不同的地方是，锁同一时刻只允许一个线程访问某一资源，而 Semaphore 则可以控制同一时刻多个线程访问某一资源。

**Notes：**
 	1、大多数时候使用Semaphore都应该是公平模式，默认是非公平模式，如果需要公平模式可以在构造函数里面指定，公平性可以 保证先进先出，不会有线程饥饿问题出现，非公平模式，不保证顺序，吞吐量会更好一些。
	2、使用Semaphore对共享资源的访问，一般指的是读取，而不是更新，这里面不要对共享变量修改，除非使用同步块来保证安全。

Semaphore适用场景： Semaphore主要用做流量控制，特别是公用资源有限的应用场景，比如数据库连接。假如有一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程并发的读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有10个，这时我们必须控制只有十个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。这个时候，我们就可以使用Semaphore来做流量控制。

Semaphore的主要方法：

1、构造函数：Semaphore提供两个构造函数，第一个构造函数创建具有给定的许可数和非公平的公平设置的 Semaphore。 第二个构造函数创建具有给定的许可数和非公平的公平设置的 Semaphore。 非公平模式下，直接调用父类的nonfairTryAcquireShared()尝试获取许可。公平模式下，先检测前面是否有排队的，如果有排队的则获取许可失败，进入队列排队，否则尝试原子更新state的值。
Notes：permits可能为负数，在这种情况下，必须在授予任何获取前进行释放。

//创建时要传入许可次数，默认使用非公平模式
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}
 //创建时传入许可次数，及是否公平模式
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

2、acquire()方法：获得信号量方法，这两个方法支持 Interrupt中断机制，如果尝试获取许可失败，会进入AQS的队列中排队。如果获取请求数量的信号量后并立即返回，将可用的信号量数减去permits。

//调用该方法时从该信号量获得一个许可
public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

//调用该方法时从该信号量获得permits个许可
public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

3、acquireUninterruptibly()：获得信号量方法，这两个方法不支持 Interrupt中断机制，其他同acquire()方法。

//调用该方法时从该信号量获得一个许可
public void acquireUninterruptibly() {
    sync.acquireShared(1);
}

//调用该方法时从该信号量获得permits个许可
public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}

4、tryAcquire()：尝试获得信号量有三个方法。

第一个方法尝试获取信号量，如果获取成功则返回true，否则马上返回false，不会阻塞当前线程。
第二个方法尝试获取信号量，如果在指定的时间内获得信号量，则返回true，否则返回false
第三个方法尝试获取指定数量的信号量，如果在指定的时间内获得信号量，则返回true，否则返回false。

public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
}

public boolean tryAcquire(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
        throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}

5、release()：释放给定数目的许可，将其返回到信号量。

public void release() {
    sync.releaseShared(1);
}

public void release(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.releaseShared(permits);
}

6、availablePermits()：该方法返回AQS中state变量的值，当前剩余的信号量个数。

public int availablePermits() {
    return sync.getPermits();
}

//=========Sync类========
final int getPermits() {
    return getState();
 }

7、drainPermits()：获取并返回立即可用的所有许可。

public int drainPermits() {
    return sync.drainPermits();
}

8、reducePermits ()：据指定的缩减量减小可用许可的数目。

protected void reducePermits(int reduction) {
    if (reduction < 0) throw new IllegalArgumentException();
    sync.reducePermits(reduction);
}

//=========Sync类========
final void reducePermits(int reductions) {
    for (;;) {
        int current = getState();
        int next = current - reductions;
        if (next > current) // underflow
            throw new Error("Permit count underflow");
        if (compareAndSetState(current, next))
            return;
    }
}

**Semaphore总结：**Semaphore，也叫信号量，通常用于控制同一时刻对共享资源的访问上，也就是限流场景；Semaphore的内部实现是基于AQS的共享锁来实现的；Semaphore初始化的时候需要指定许可的次数，许可的次数是存储在state中；获取一个许可时，则state值减1；释放一个许可时，则state值加1；可以动态减少n个许可；可以动态增加n个许可。

本文参考
本文主要参考以下文章，谨以技术分享为目的，将此文搬到CSDN上，如有侵权问题请联系本人，乐于分享提高。
作者： jijs
链接：https://www.jianshu.com/p/d1bfa69f864d