Semaphore意思为信号量。用于限制对某一资源的同时访问量。

构造器

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

permits是必传项，用于控制访问同一资源的并发数

  1. NonfairSync(int permits) {
  2.     super(permits);
  3. }
  5. Sync(int permits) {
  6.     setState(permits);
  7. }

由非公平锁的构造器可以看出，该值存于aqs的volatile修饰的state值

acquire()获取访问资源的信号

  1.     public void acquire() throws InterruptedException {
  2.         sync.acquireSharedInterruptibly(1);//获取aqs共享锁
  3.     }

这里只分析非公平锁的实现:

  1.     public final void acquireSharedInterruptibly(int arg)
  2.             throws InterruptedException {
  3.         if (Thread.interrupted())//中断标识
  4.             throw new InterruptedException();
  5.         if (tryAcquireShared(arg) < 0)//获取锁，小于0，说明共享锁已经用完了
  6.             doAcquireSharedInterruptibly(arg);//加入aqs队列
  7.     }
  1.         protected int tryAcquireShared(int acquires) {
  2.             return nonfairTryAcquireShared(acquires);
  3.         }
  1.         final int nonfairTryAcquireShared(int acquires) {
  2.             for (;;) {
  3.                 int available = getState();//获取当前state状态（剩余信号量）
  4.                 int remaining = available - acquires;//减去当前需要的信号量
  5.                 if (remaining < 0 ||//小于0，获取不到信号量
  6.                     compareAndSetState(available, remaining))//cas去抢占信号量
  7.                     return remaining;
  8.             }
  9.         }

源码可以看出，每个线程过来都用cas操作state-1去获取信号.如果小于0说明信号量已经被使用完毕。
如果信号量aqs，使用完毕，则加入aqs队列

  1.     private void doAcquireSharedInterruptibly(int arg)
  2.         throws InterruptedException {
  3.         final Node node = addWaiter(Node.SHARED);//创建等待节点，并将节点加入aqs队列
  4.         boolean failed = true;
  5.         try {
  6.             for (;;) {
  7.                 final Node p = node.predecessor();
  8.                 if (p == head) {//前节点是head节点
  9.                     int r = tryAcquireShared(arg);//去抢占资源
  10.                     if (r >= 0) {//抢占成功
  11.                         setHeadAndPropagate(node, r);
  12.                         p.next = null; // help GC
  13.                         failed = false;
  14.                         return;
  15.                     }
  16.                 }
  17.                 if (shouldParkAfterFailedAcquire(p, node) &&
  18.                     parkAndCheckInterrupt())
  19.                     throw new InterruptedException();
  20.             }
  21.         } finally {
  22.             if (failed)
  23.                 cancelAcquire(node);
  24.         }
  25.     }

release()去释放信号

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

通过同步器去释放锁

  1.     public void release() {
  2.         sync.releaseShared(1);
  3.     }
  1.     public final boolean releaseShared(int arg) {
  2.         if (tryReleaseShared(arg)) {//释放共享锁
  3.             doReleaseShared();//唤醒aqs队列中等待的队列
  4.             return true;
  5.         }
  6.         return false;
  7.     }

释放共享锁。及通过cas让state+1

  1.         protected final boolean tryReleaseShared(int releases) {
  2.             for (;;) {//自旋
  3.                 int current = getState();
  4.                 int next = current + releases;
  5.                 if (next < current) // overflow
  6.                     throw new Error("Maximum permit count exceeded");
  7.                 if (compareAndSetState(current, next))//cas去加回state
  8.                     return true;
  9.             }
  10.         }

释放后唤醒aqs中等待的头节点

  1.     private void doReleaseShared() {
  2.         for (;;) {
  3.             Node h = head;
  4.             if (h != null && h != tail) {
  5.                 int ws = h.waitStatus;
  6.                 if (ws == Node.SIGNAL) {
  7.                     if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
  8.                         continue;            // loop to recheck cases
  9.                     unparkSuccessor(h);//唤醒排在第一的线程
  10.                 }
  11.                 else if (ws == 0 &&
  12.                          !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
  13.                     continue;                // loop on failed CAS
  14.             }
  15.             if (h == head)                   // loop if head changed
  16.                 break;
  17.         }
  18.     }

这里只分析非公平锁，公平锁的差异只是在抢占锁之前，会先分析aqs队列中是否有等待队列，如果有的话，不尝试获取，而是直接加入aqs队列。