Semaphore信号量

信号量Semaphore是一个控制访问多个共享资源的计数器，和CountDownLatch一样，其本质上是一个“共享锁”。

Semaphore介绍

Semaphore在API是这么介绍的：

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前阻塞每一个acquire()，然后在获得该许可。每个release()添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

Semaphore通常用于控制当前访问某些资源的线程个数，并提供了同步机制
举个简单的例子来阐述Semaphore：
假如有这么一个场景，一个厕所有5个坑位，刚开始全部空着，来了3个人，占了3个坑，然后又来了3个人，这个时候由于只有2个坑位，所以只能2个人，另外一个人只能候着，直到坑位空出来。包括后面来的人，也必须在外面候着。当坑位空着了，另外等待的人可以随机进去还是按照先来后到的顺序进去，这取决于构造Semaphore对象传入的参数选项。

从程序的角度来看，厕所坑位就相当于信号量Semaphore，其中许可数为5，上厕所的人就相当于线程，当进来一个人许可数就减1，当没有了坑位（许可就为0了）

信号量是一个非负整数(大于等于1)，当一个线程访问共享资源时，它必须先获取Semaphore，当Semaphore>0时，获取该资源并使Semaphore-1，若Semaphore为0，则表示全部的共享资源已经被其他线程占用，必须等待其他线程释放资源。

Semaphore分析

从Semaphore源码来看，其内部结构包含了FairSync（公平锁）和NonfairSync（非公平锁），基础内部类Sync，其中Sync继承AQS（AQS很重要）。

构造函数

Semaphore提供2个构造函数：

Semaphore(int permits)，创建具有给定的许可数和非公平的公平设置的 Semaphore

     public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

Semaphore(int permits, boolean fair)，创建具有给定的许可数和给定的公平设置的 Semaphore

     public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

Semaphore默认选择非公平锁，当信号量Semaphore=1时，它可以当做互斥锁使用。其中0,1就相当于它的状态，当为1时表示其他线程可以获取；当为0时，即其他线程必须等待。

信号量获取

Semaphore提供了acquire()方法来获取一个许可

     public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

内部调用AQS的acquireSharedInterruptibly(int arg)，该方法以共享模式获取同步状态：

     public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

信号量释放

Semaphore提供release()来释放许可

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

内部调用的AQS中的releaseShared():

     public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

代码示例

就拿上面的厕所坑位来举例：

 public class SemaphoreDemo {
    public static void main(String[] args) throws Exception{
        ExecutorService service = Executors.newCachedThreadPool();
        //5个坑位
        final Semaphore semaphore = new Semaphore(5);
        //10个人排队
        for (int i = 0; i < 10; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println("线程" + Thread.currentThread().getName() + "进入，当前已有" + (5 - semaphore.availablePermits()) + "个并发");
                        Thread.sleep((long) (Math.random()*10000));
                        System.out.println("线程" + Thread.currentThread().getName() + "即将离开");
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
 
                }
            };
            service.execute(runnable);
        }
    }
}

运行结果如下：

线程pool-1-thread-2进入，当前已有2个并发
线程pool-1-thread-1进入，当前已有2个并发
线程pool-1-thread-3进入，当前已有3个并发
线程pool-1-thread-4进入，当前已有4个并发
线程pool-1-thread-5进入，当前已有5个并发
线程pool-1-thread-2即将离开
线程pool-1-thread-6进入，当前已有5个并发
线程pool-1-thread-3即将离开
线程pool-1-thread-7进入，当前已有5个并发
线程pool-1-thread-4即将离开
线程pool-1-thread-8进入，当前已有5个并发
线程pool-1-thread-5即将离开
线程pool-1-thread-9进入，当前已有5个并发
线程pool-1-thread-9即将离开
线程pool-1-thread-10进入，当前已有5个并发
线程pool-1-thread-7即将离开
线程pool-1-thread-8即将离开
线程pool-1-thread-10即将离开
线程pool-1-thread-1即将离开
线程pool-1-thread-6即将离开

# java并发