【JUC源码解析】Semaphore

简介

Semaphore（信号量），概念上讲，一个信号量持有一组许可(permits)。

概述

线程可调用它的acquire()方法获取一个许可，不成功则阻塞；调用release()方法来归还一个许可，前提是已经拿到过一个许可。然而，并没有什么实际的许可对象，Semaphore只是记录了一个数字，并根据这个数字管控线程。

应用

描述

有一组数据items，其实是26个大写的英文字母，有52个线程从中取数据（getItem），每个线程取一个数据，有一个线程不停地往里面放数据（putItem）直至取数据的52个线程都取到了数据。有一个信号量（Semaphore）,要求同时只能有10个线程从中取数据（取数据之前会拿一个许可，共有10许可），除非，某个线程取得的数据，又被放数据的线程放进去了，模拟取数据线程操作结束，把许可证归还，其他取数据线程才能从中拿到许可，然后取数据。

代码

 public class Pool {
     private static final int MAX_AVAILABLE = 10;
     private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

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

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

     private static void sleep(int sleep) {
         try {
             Thread.sleep(sleep);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
     }

     protected boolean[] used = new boolean[MAX_AVAILABLE];

     protected synchronized String getNextAvailableItem() {
         for (int i = 0; i < MAX_AVAILABLE; ++i) {
             if (!used[i]) {
                 used[i] = true;
                 return items[i];
             }
         }
         return null;
     }

     int len = 26;
     protected String[] items = new String[len];
     {
         initial(0);
     }

     void initial(int sleep) {
         for (int i = 0; i < len; i++) {
             sleep(sleep);
             items[i] = String.valueOf((char) (i + 65));
             putItem(items[i]);
         }
     }

     protected synchronized boolean markAsUnused(String 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;
     }

     public static void main(String[] args) {
         final Pool pool = new Pool();

         final AtomicBoolean hasDone = new AtomicBoolean(false);

         ExecutorService es = Executors.newFixedThreadPool(52);

         new Thread(new Runnable() { // 计时器，每10毫秒记录一次
             @Override
             public void run() {
                 while (!hasDone.get()) {
                     System.out.print(".");
                     sleep(10);
                 }

             }
         }).start();
         new Thread(new Runnable() { // 1秒后，每20毫秒添加一个元素
             @Override
             public void run() {
                 sleep(1000);
                 while (!hasDone.get()) {
                     pool.initial(20);
                 }
             }
         }).start();

         final CyclicBarrier barrier = new CyclicBarrier(52, new Runnable() {
             @Override
             public void run() {
                 hasDone.set(true);
             }
         });
         for (int i = 0; i < 52; i++) {
             es.execute(new Runnable() {
                 @Override
                 public void run() {
                     try {
                         System.out.println(Thread.currentThread() + " << " + pool.getItem());
                         barrier.await();
                     } catch (InterruptedException e) {
                         Thread.currentThread().interrupt();
                     } catch (BrokenBarrierException e) {
                         e.printStackTrace();
                     }
                 }
             });
         }
         es.shutdown();
     }
 }

输出

.Thread[pool-1-thread-1,5,main] << A
Thread[pool-1-thread-2,5,main] << B
Thread[pool-1-thread-3,5,main] << C
Thread[pool-1-thread-4,5,main] << D
Thread[pool-1-thread-5,5,main] << E
Thread[pool-1-thread-6,5,main] << F
Thread[pool-1-thread-7,5,main] << G
Thread[pool-1-thread-8,5,main] << H
Thread[pool-1-thread-10,5,main] << I
Thread[pool-1-thread-9,5,main] << J
...............................................................................................Thread[pool-1-thread-12,5,main] << A
..Thread[pool-1-thread-11,5,main] << B
..Thread[pool-1-thread-13,5,main] << C
..Thread[pool-1-thread-14,5,main] << D
..Thread[pool-1-thread-15,5,main] << E
..Thread[pool-1-thread-16,5,main] << F
..Thread[pool-1-thread-17,5,main] << G
..Thread[pool-1-thread-18,5,main] << H
..Thread[pool-1-thread-19,5,main] << I
.Thread[pool-1-thread-20,5,main] << J
...............................Thread[pool-1-thread-21,5,main] << A
..Thread[pool-1-thread-22,5,main] << B
..Thread[pool-1-thread-24,5,main] << C
..Thread[pool-1-thread-23,5,main] << D
..Thread[pool-1-thread-25,5,main] << E
..Thread[pool-1-thread-26,5,main] << F
..Thread[pool-1-thread-27,5,main] << G
..Thread[pool-1-thread-28,5,main] << H
..Thread[pool-1-thread-29,5,main] << I
..Thread[pool-1-thread-30,5,main] << J
.................................Thread[pool-1-thread-31,5,main] << A
...Thread[pool-1-thread-32,5,main] << B
.Thread[pool-1-thread-33,5,main] << C
..Thread[pool-1-thread-34,5,main] << D
..Thread[pool-1-thread-35,5,main] << E
..Thread[pool-1-thread-36,5,main] << F
..Thread[pool-1-thread-37,5,main] << G
..Thread[pool-1-thread-38,5,main] << H
..Thread[pool-1-thread-39,5,main] << I
..Thread[pool-1-thread-42,5,main] << J
.................................Thread[pool-1-thread-41,5,main] << A
..Thread[pool-1-thread-40,5,main] << B
..Thread[pool-1-thread-43,5,main] << C
..Thread[pool-1-thread-44,5,main] << D
..Thread[pool-1-thread-52,5,main] << E
..Thread[pool-1-thread-45,5,main] << F
..Thread[pool-1-thread-51,5,main] << G
..Thread[pool-1-thread-50,5,main] << H
..Thread[pool-1-thread-49,5,main] << I
..Thread[pool-1-thread-48,5,main] << J
.................................Thread[pool-1-thread-47,5,main] << A
..Thread[pool-1-thread-46,5,main] << B

从上面输出可知，每10条记录，都要等一段时间，恰好体现了信号量管控的现象

源码分析

同步器对象

     private final Sync sync; // 同步器对象

内部类

Sync

     abstract static class Sync extends AbstractQueuedSynchronizer { // 内部类，继承自AQS
         private static final long serialVersionUID = 1192457210091910933L;

         Sync(int permits) { // 构造方法
             setState(permits); // 初始化许可的个数，对应state
         }

         final int getPermits() { // 获取当前许可的个数
             return getState();
         }

         final int nonfairTryAcquireShared(int acquires) { // 获取锁，默认非公平锁
             for (;;) {
                 int available = getState(); // 获取当前state，可用permits个数
                 int remaining = available - acquires; // 可用 - 获取 = 剩余
                 if (remaining < 0 || compareAndSetState(available, remaining)) // 如果remaining小于0，直接返回；否则CAS
                                                                                 // state为remaining，成功则返回，失败，则重新获取
                     return remaining;
             }
         }

         protected final boolean tryReleaseShared(int releases) { // 释放锁
             for (;;) {
                 int current = getState(); // 获取当前状态
                 int next = current + releases; // 当前值 + 释放值 = 下次可用值
                 if (next < current) // 溢出，说明releases的值小于0
                     throw new Error("Maximum permit count exceeded");
                 if (compareAndSetState(current, next)) // CAS state
                                                         // 为next，成功则返回；否则，重新获取并释放
                     return true;
             }
         }

         final void reducePermits(int reductions) { // 减少许可个数
             for (;;) {
                 int current = getState(); // 当前可用的个数
                 int next = current - reductions; // 剩余
                 if (next > current) // 说明reductions小于0
                     throw new Error("Permit count underflow");
                 if (compareAndSetState(current, next)) // CAS state为next，成功则返回；否则，重新获取并减少
                     return;
             }
         }

         final int drainPermits() { // 排空许可，即情况所有的许可
             for (;;) {
                 int current = getState(); // 获取当前状态
                 if (current == 0 || compareAndSetState(current, 0)) // CAS state
                                                                     // 为0
                     return current;
             }
         }
     }

NonfairSync

     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); // 直接调用父类方法
         }
     }

FairSync

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

构造方法

     public Semaphore(int permits) {
         sync = new NonfairSync(permits); // 默认非公平
     }

     public Semaphore(int permits, boolean fair) { // 根据fair参数选择公平或非公平
         sync = fair ? new FairSync(permits) : new NonfairSync(permits);
     }

其它方法

     public void acquire() throws InterruptedException {
         sync.acquireSharedInterruptibly(1); // 获取许可，响应中断
     }

     public void acquireUninterruptibly() {
         sync.acquireShared(1); // 不响应中断
     }

     public boolean tryAcquire() {
         return sync.nonfairTryAcquireShared(1) >= 0; // false: < 0   true: > 0
     }

     public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
         return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout)); // 支持超时
     }

     public void release() {
         sync.releaseShared(1); // 释放许可
     }

     public void acquire(int permits) throws InterruptedException { // 获取多个
         if (permits < 0)
             throw new IllegalArgumentException();
         sync.acquireSharedInterruptibly(permits); // 响应中断
     }

     public void acquireUninterruptibly(int permits) { // 不响应中断
         if (permits < 0)
             throw new IllegalArgumentException();
         sync.acquireShared(permits);
     }

     public boolean tryAcquire(int permits) { //  false: < 0   true: > 0
         if (permits < 0)
             throw new IllegalArgumentException();
         return sync.nonfairTryAcquireShared(permits) >= 0;
     }

     public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException {
         if (permits < 0)
             throw new IllegalArgumentException();
         return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout)); // 支持超时
     }

     public void release(int permits) { // 释放多个
         if (permits < 0)
             throw new IllegalArgumentException();
         sync.releaseShared(permits);
     }

     public int availablePermits() { // 可用的许可个数
         return sync.getPermits();
     }

     public int drainPermits() { // 排空
         return sync.drainPermits();
     }

     protected void reducePermits(int reduction) { // 减少
         if (reduction < 0)
             throw new IllegalArgumentException();
         sync.reducePermits(reduction);
     }

     public boolean isFair() { // 是否是公平的
         return sync instanceof FairSync;
     }

     public final boolean hasQueuedThreads() {
         return sync.hasQueuedThreads(); // 队列里是否还有等待的线程
     }

     public final int getQueueLength() {
         return sync.getQueueLength(); // 队列长度，等待线程的个数
     }

     protected Collection<Thread> getQueuedThreads() {
         return sync.getQueuedThreads(); // 获取在对列里等待的线程
     }

     public String toString() { // toString()方法
         return super.toString() + "[Permits = " + sync.getPermits() + "]";
     }

源码比较简单。

行文至此结束。

尊重他人的劳动，转载请注明出处：http://www.cnblogs.com/aniao/p/aniao_semaphore.html