Java并发学习(十五)-并发工具Semaphore

What is Semaphore

一个并发工具Semaphore，位于java.util.concurrent 下面，在并发家族里面充当着工具类的角色。
那么Semaphore作为一个工具，有什么作用呢？
控制容量，就好比一个停车场，容量为100，已经听了50，所以此时还能再停50，如果已经停了100的话，那么外面的车就进不去了，只能在外面等。此时当有车出来时，才能有车进去。

具体实现

首先看Semaphore的定义：

public class Semaphore implements java.io.Serializable

很简单定义，就实现了Serializable。里面则是通过AbstractQueuedSynchronizer来实现的，本质是一把共享锁，但是会控制量，也就是控制并发访问量，其他超出的，就会在队列中挂起，处于等待状态，具体可看：Java并发学习(三)-AbstractQueuedSynchronizer 。

里面实现了两种锁获取的机制，即公平锁和非公平锁。

看看其内部主要构造代码：

    // 自己内部基于AQS实现的同步器。
    private final Sync sync;

    abstract static class Sync extends AbstractQueuedSynchronizer {

        /**
         * permits也就是state变量。
         * @param permits
         */
        Sync(int permits) {
            setState(permits);
        }

        final int getPermits() {
            return getState();
        }
        ...
}

最初构造方法传入的permits，就用于父类去初始化state变量。以后每次释放或者获取，都是通过父类调用CAS原子操作实现。
以下分别以公平锁模式和非公平锁模式来说明获取和释放锁。

公平锁FairSync

获取锁：

        protected int tryAcquireShared(int acquires) {
            for (;;) {
            //判断head后面，是否有代执行节点
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                //修改执行状态
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

上述代码中，调用了hasQueuedPredecessors，下面主要看这个方法：

    public final boolean hasQueuedPredecessors() {
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

Java doc中对其的注释就是，查看是否队列中是否，还有其他的线程整个等待获取锁，也就是在head（AQS设计当前获取锁的为head）后面，是否有一个node在等待获取锁，并且此node不是当前线程的node。

这样一来，公平锁的具体意思就是，当任意线程性要去获取锁的时候，首先看下有没有排队的，有排队的话，我就获取不到，我得等。

而在AQS实现里面，当获取不到时候进行自旋时，就会判断该线程需不需要挂起并进行排队，放到队列里面。这里就不深讲，可以去看AQS相关。

非公平锁NonfairSync

非公平锁，相对来说比公平锁实现要简单很多，它直接去尝试更改state状态，而不询问是否有排队的。

        final int nonfairTryAcquireShared(int acquires) {
            //阻塞性，去更改state。非公平，也就是强行去更改，而不是通过队列来更改。
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

释放锁

释放锁，则是直接调用父类方法，将state变量进行更改：

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

再看父类的releaseShared：

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

调用子类的：tryReleaseShared

        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }

而doReleaseShared方法则是唤醒下一个节点，让他自己去竞争锁，这里就和公平和非公平无关了。

用途&例子

前面讲过，Semaphore主要用于访问量容量的控制，比如数据库连接。假如有一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程并发的读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有5个，这时我们必须控制只有五个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。这个时候，我们就可以使用Semaphore来做流控，代码如下：

public class SemaphoreTest {
    private static final int THREAD_COUNT = 30;
    private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
    //设置Semaphore信号量
    private static Semaphore s = new Semaphore(5);
    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        //需要获取信号量
                        s.acquire();
                        System.out.println("save data");
                        //释放信号量
                        s.release();
                    } catch (InterruptedException e) {
                    }
                }
            });
        }
        threadPool.shutdown();
    }
}

参考资料：
1. https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Semaphore.html
2. http://ifeve.com/concurrency-semaphore/