Java信号量Semaphore详解

导入

Semaphore实现为一种基于计数的信号量，Semaphore管理着一组虚拟的许可集合，这种许可可以作为某种凭证，来管理资源，在一些资源有限的场景下很有实用性，比如数据库连接，应用可初始化一组数据库连接，然后通过使用Semaphore来管理获取连接的许可，任何线程想要获得一个连接必须首先获得一个许可，然后再凭这个许可获得一个连接，这个许可将持续到这个线程归还了连接。在使用上，任何一个线程都需要通过acquire来获得一个Semaphore许可，这个操作可能会阻塞线程直到成功获得一个许可，因为资源是有限的，所以许可也是有限的，没有获得资源就需要阻塞等待其他线程归还Semaphore，而归还Semaphore操作通过release方法来进行，release会唤醒一个等待在Semaphore上的一个线程来尝试获得许可。如果想要达到一种互斥的效果，比如任何时刻只能有一个线程获得许可，那么就可以初始化Semaphore的数量为1，一个线程获得这个Semaphore之后，任何到来的通过acquire来尝试获得许可的线程都会被阻塞直到这个持有Semaphore的线程调用了release方法来释放Semaphore。

在实现上，Semaphore借助了线程同步框架AQS，AQS的分析可以参考文章Java同步框架AbstractQueuedSynchronizer，同样借助了AQS来实现的是java中的可重入锁的实现，同样你可以在文章Java可重入锁详解中找到java中可重入锁的分析总结文档。在这些文章中已经分析过如何通过AQS来实现锁的语义，本文将继续分析AQS的应用实例，Semaphore作为一种线程间同步机制是非常轻量级的方案，所以学习和掌握Semaphore是有必要的。

信号量Semaphore

Semaphore的实现借助了同步框架AQS，下面的图片展示了Semaphore的代码结构，Semaphore使用一个内部类Sync来实现，而Sync继承了AQS来实现，Sync有两个子类，分别对应着公平模式和非公平模式的Semaphore，下文中会分析两者的实现细节。

首先来看一下Sync的构造函数：

Sync(int permits) {
  setState(permits);
}

参数即为需要管理的许可数量，Sync使用AQS提供的setState方法来初始化共享变量state，后续通过acquire和release来获取和规划许可。下面首先分析的是公平模式下的获取许可方法：

    protected int tryAcquireShared(int acquires) {
        for (;;) {
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
        }
    }
        
    public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        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());
    }

hasQueuedPredecessors方法表示的是是否有线程在等待许可，如果已经有线程在等待了，那么直接返回-1代表获取许可失败，否则再去获取，获取许可就是通过compareAndSetState方法来更新state的值，下面来看一下非公平模式下的获取许可的方法：

final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
}

非公平模式和公平模式的区别在于公平模式会考虑是否已经有线程在等待，而非公平模式会快速去竞争，不会考虑是否有线程在前面等待，关于多个线程是如何去竞争共享变量而获得锁语义的内容需要参考文章Java同步框架AbstractQueuedSynchronizer。下面来分析一下上面分析的两个方法是如何被调用的，上文中提到，我们是通过使用acquire方法来获得一个许可的，下面是Semaphore的acquire方法：

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

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

acquire方法调用了AQS基类的acquireSharedInterruptibly方法，而acquireSharedInterruptibly方法调用了其子类的tryAcquireShared方法，对应了公平模式和非公平模式下的tryAcquireShared方法。上面分析了获取许可的方法acquire，下面再来分析一下归还许可的方法release：

    public void release() {
        sync.releaseShared(1);
    }
    
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }    

    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;
            }
     }

获取许可是通过减少state来完成的，而归还许可则是通过增加state来完成的，AQS通过维护一个共享变量state来实现多线程同步。为了更好的理解Semaphore的工作原理，下面展示一个使用示例，先来看代码：

class Resource {

    /**
     * The resource
     * @return r
     */
    public Object getResource() {
        return new Object();
    }
}

/**
 *  The Thread Pool
 */
class Pool {
    private static final int MAX_AVAILABLE = 100;
    private final int availableSemaphore;
    private Semaphore available;

    public Pool() {
        this(MAX_AVAILABLE);
    }

    public Pool(int available) {
        this(available, false);
    }

    public Pool(int available, boolean fairMode) {
        this.availableSemaphore = available;
        this.available = new Semaphore(available, fairMode);

        items = new Resource[availableSemaphore];

        for (int i = 0; i < availableSemaphore; i ++) {
            items[i] = new Resource();
        }

        used = new boolean[availableSemaphore];
    }

    public int availableSemaphore() {
        return this.availableSemaphore;
    }

    public Object getItem() throws InterruptedException {
      available.acquire();
      return getNextAvailableItem();
    }

    public void putItem(Object x) {
      if (markAsUnused(x))
        available.release();
    }

    // Not a particularly efficient data structure; just for demo
    protected Object[] items;
    protected boolean[] used;

    private synchronized Object getNextAvailableItem() {
      for (int i = 0; i < MAX_AVAILABLE; ++i) {
        if (!used[i]) {
          used[i] = true;
           return items[i];
        }
      }
      return null; // not reached
    }

    private synchronized boolean markAsUnused(Object item) {
      for (int i = 0; i < MAX_AVAILABLE; ++i) {
        if (item == items[i]) {
           if (used[i]) {
            used[i] = false;
            return true;
           } else
             return false;
        }
      }
      return false;
    }
}

Pool类使用了Semaphore来管理一组许可，获得许可的线程可以获得一个Resource，而Resource是什么可以自定义，比如是数据库连接池。调用Pool类的getItem可以获得一个许可，而调用putItem将许可归还给Pool，下面展示了Pool的简单使用示例：

/**
 * Created by hujian06 on 2017/10/21.
 *
 * Semaphore demo
 */
public class SemaphoreDemo {

    public static void main(String ... args) {

        Pool pool = new Pool();
        Object resource = null;

        try {
            Resource r = (Resource) pool.getItem();

             resource = r.getResource();

            //do your biz

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            pool.putItem(resource); //release here
        }

    }

}

需要注意的是，任何线程在获得许可之后，使用共享资源完毕都需要执行归还操作，否则会有线程一直在等待。本文的内容到此也就结束了，Semaphore只是使用AQS的一种简单例子，AQS的强大之处就在于，你仅仅需要继承他，然后使用它提供的api就可以实现任意复杂的线程同步方案，AQS为我们做了大部分的同步工作，所以本文可以当成是对使用AQS的一种简单介绍，你应当去分析一下AQS的实现细节，并且加以总结，可以这么说，理解了AQS，就理解了java中线程同步是如何实现的，线程同步是并发的核心内容，如何保证多个线程可以安全高效的访问共享数据，是并发需要首要考虑的问题，而AQS解决了这些问题，未来还会对AQS进行深入分析总结。