Semaphore实现Andoird版源码剖析

Semaphore是一个计数的信号量。从概念上来说，信号量维持一组许可（permits）。acquire方法在必须的时候都会阻塞直到有一个许可可用，然后就会拿走这个许可。release方法添加一个许可，会有可能释放一个阻塞中的获取者（acquirer）。然而，Semaphore没有使用真实的许可对象，只是保持一个可用计数并且采取相应的行为。

信号量一般用于限制可以访问一些（物理上或者逻辑上）的资源的并发线程数。

    信号量初始化为1的时候，意味着它最多只有一个允许可用，这样就能作为互斥独占锁使用。这种更多地被称为二进制信号量（binary semaphore），因为它只有两个状态：一个许可可用，或者0个许可可用。当使用这种方式的时候，二进制信号量就有这样的属性（不像大部分锁的实现）：锁可以被拥有者（就如信号量没有拥有者的概念）之外的另外线程释放。这种属性在某些特殊的上下文中很有用，例如死锁恢复。
    类的构造函数可选地接受一个fairness参数。当设为false的时候，该类就不会保证线程获取许可的顺序。特别地，插队是允许的，也就是说，线程调用acquire方法可以在另外的等待线程之前分配许可————逻辑上新线程会把自己放在等待线程队列头。当fairness设为true，信号量就保证调用acquire方法的线程会以它们调用方法的处理顺序来获取许可（FIFO）。注意FIFO的顺序决定特指在这些方法的内部执行点。因此，有可能一条线程在另外一条线程之前调用了acquire方法，但实际顺序会在另外一条线程之后，同样也适用于函数返回的先后顺序。同样要注意非超时版本tryAcquire方法不会遵循fairness设置，会马上获取任何可用的许可。
    一般来说，信号量用来控制资源访问的话，就应该被初始化为公平（fairness设为true），这样可以确保没有线程会在访问资源的时候饿坏。当使用在其他同步控制的情况下使用信号量，非公平的吞吐量优势一般优于公平的考虑。

    其实总体上来看，fairness参数以及状态量的概念很接近AQS（AbstractQueuedSynchronizer）提供的功能，因此大家也应该猜到Semaphore的内部实现也是通过一个继承AQS的内部类实现接口功能。接下来我们仔细看看内部的实现。

具体实现

    先来看看Semaphore的构造函数：

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


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

    可以看到构造函数与ReentrantLock实现类似，都是按照fair参数分配创建不同的锁类，再来看看Semaphore的acquire和release的接口实现

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


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

    可以看到acquire和release的实现都是调用内部类Sync的方法实现，当然了，这些方法也就是AQS提供出来的获取和释放共享锁接口。接下来看看整个实现里最主要的内部类Sync的相关实现：

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;


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


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


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

        //省略一些次要方法
    }


    /**
     * 非公平版本
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;


        NonfairSync(int permits) {
            super(permits);
        }


        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }


    /**
     * 公平版本
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;


        FairSync(int permits) {
            super(permits);
        }


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

    为了方便了解主要逻辑，Sync类省略掉一些次要的方法。非公平版本NonfairSync类和公平版本FairSync类都继承于Sync类，Sync类继承于AQS类，NonfairSync和FairSync类都有同样的tryReleaseShared实现，只不过在tryAcquireShared实现上有稍微不同。
    先来看看非公平类NonfairSync实现。tryAcquireShared调用的是Sync类的nonfairTryAcquireShared方法，方法的实现相当简单，只是在循环内判断当前锁状态值减去请求值acquires后，如果remaining < 0（则表示此次acquire失败，直接返回负值remaining即可）或者remaining >=0 时，compareAndSetState成功（表示此次acquire成功，直接返回大于等于0的remaining即可），如果CAS失败，则继续循环重试，直到其中一种情况发生。
    再来看看公平类FairSync的实现。tryAcquireShared直接被重写，与非公平类版本对比，增加了hasQueuedPredecessors的判断，该方法在AQS中表示是否有结点在当前的等待队列前排在自己前面，如果返回true，则表示当前线程需要进入等待队列，直接返回-1表示acquire失败。
    tryReleaseShared的实现也很简单，也是一个循环里不断CAS把锁状态增加请求的releases即可。
    Semaphore还有其它一些辅助方法，其实现也都是简单地调用内部类Sync的方法，这里便不再赘述。

总结
    总体来看，AQS的锁状态值就等于Semaphore的许可量，acquire的实现就是把当前锁状态值，也就是许可量减去对应值，release的实现就是把锁状态值增加对应值即可。整个实现结构和ReentrantLock类似，但没有了重入的逻辑，而且实现更是相对简单，理解起来应该没有难度。