信号量Semaphore 工作原理

限流器：让一组线程只能同时让固定数量的线程同时执行。各种同步器其实都是基于AQS实现的。其中最重要的是 state  和里面的同步等待队列，说明就是一个链表

Semaphore semp = new Semaphore(5);

   也可以声明为公平的同步构造器

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

 

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

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

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

此致，构造方法其实就是申明了 state 的值，我先告诉大家大概原理，再来追踪源码，所有线程都会尝试通过 CAS的方式对state值减一操作，如果操作成功并且 state 的值大于0 ，则获得执行权限，可以执行，否则放入同步队列，并且进入阻塞。

   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)//这个方法尝试对state减一并且返回state 后的值，如果返回后的值小于0，则调用下面的方法
            doAcquireSharedInterruptibly(arg);
    }

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

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

                  //很简单的逻辑判断，参数 acquires==1，如果减一之后小于0，或者CAS减一操作成功，则直接返回，可以直接往下                    执行，没有任何阻塞操作。
                    return remaining;
            }
        }

 

接着看  doAcquireSharedInterruptibly(arg);不用看都能猜到是会进行一下阻塞操作

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED); 添加一个节点，并且设置到队列尾部
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

先来看看这个addWaiter 方法，这个方法从名字上看就是添加一个等待节点。

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;  申明一个节点变量指向 tail 尾部节点。
        if (pred != null) {  如果尾部节点不为空，
            node.prev = pred; 则设置当前新建的节点的前一个节点为尾部节点
            if (compareAndSetTail(pred, node)) { 用 CAS方式 设置当前节点为尾部节点
                pred.next = node;
                return node;
            }
        }
        enq(node); 这个方法的意思就是吧当前节点弄到等待队列的尾部去。这里还没看见让线程停止运行的痕迹，还要往下看
        return node;
    }

看下这个 enq(node); 

 private Node enq(final Node node) {
        for (;;) { 自旋，不断尝试
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))  这里判断头节点是否为null，为null则设置为头部，其实就是判断这个等待队列                里面有没有人，没有人就放着最前面的意思，接下来这行代码也是这个意思
                    tail = head;
            } else {
                node.prev = t; 如果这个队列已经有等待的其他节点了，就放到接下来下一个位置，当前节点的前一个节点等于尾部节点
                if (compareAndSetTail(t, node)) {  判断内存中tail字段的值是否发生了改变，如果没有则设置node节点为尾部节点，                     并且返回，结束死循环 
                    t.next = node;
                    return t;
                }
            }
        }
    }

 

接着看刚才那个方法

 private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED); 前面分析结果就是让等待队列中添加一个节点
        boolean failed = true;
        try {
            for (;;) {  又自旋，
                final Node p = node.predecessor(); 我们来看看这个是啥意思     AQS 里面有个属性volatile Node prev;   这个方法没多大意思，就是node =prev 这个逻辑而已。
                if (p == head) {
                    int r = tryAcquireShared(arg); 这个唯一逻辑就是  return (getState() == 0) ? 1 : -1;
                    if (r >= 0) {  等同getState() == 0 ，就是可以接着执行，不用阻塞啦。
                        setHeadAndPropagate(node, r); 大概意思就是唤醒当前线程 。核心 LockSupport.unpark(s.thread); 

                      这里多说两句，LockSupport.park() 消费运行许可证，一次性消费完，就算生产再多，调用两次park()将进入阻塞                          状态，unpark 是生产许可证。

                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())     

             //  parkAndCheckInterrupt() 方法的唯一逻辑 ： LockSupport.park(this);return Thread.interrupted();很明显是让线程停止运行
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

 

在来看看线程执行完了要调用 

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

    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) { //对state 加一操作，就是上厕所来比喻，本来一个厕所五个位置，一个人出来后，剩余位置就多了一个，state其实维护的是剩余的位置数量
            doReleaseShared();//核心逻辑就是对阻塞队列头部的线程进行LockSupport.unpark()生产运行许可证，可以理解为唤醒操作
            return true;
        }
        return false;
    }

 

总结一下: 所有线程开始的时候都试图对state值进行CAS减一操作，是占位置，如果占位置成功，则对state减一，否则包装一个node节点，放到等待队列尾部去，并且调用LockSupport.park()方法进行阻塞操作。拥有运行权限的线程执行完后，会释放位置，对state进行加一操作。并且唤醒等待队列中头部的线程。