Java并发编程-信号量Semaphore

    Semaphore是一个计数信号量，与concurrent.locks或者synchronized锁相比（任意时刻只允许一个线程访问某个特定的资源），它可以控制同时访问特定资源的线程数量。可以将Semaphore理解为许可证的集合，实际上没有使用任何许可证对象。创建Semaphore时需要指定许可证数目，即由此来限制同时执行的线程数量。调用acquire()方法是从Semaphore中获取一个可用许可证，无可用许可证时将会阻塞。release()方法将会释放一个可用许可证到Semaphore。

1.构造方法：

Semaphore访问方式有两种:公平和非公平方式，非公平方式下，无法保证线程获取许可证的顺序。

public Semaphore(int permits){} //默认非公平的方式
public Semaphore(int permits, boolean fair){} //指定访问的模式

•  其中permits是许可证数量，允许同时访问的线程数量。

2.常见的方法：

//从信号量中获取一个许可证
public void acquire();
//释放一个许可证
public void release();
//尝试获取一个许可证，若获取成功返回true，若获取失败返回false
public void tryAcquire();

3.其他方法：

//从Semaphore中获取许可证，在有可用的许可证前方法将阻塞。
public void acquireUninterruptibly()
//从Semaphore中获取指定数量的许可证，在指定数量的许可证可用前将阻塞。
public void acquireUninterruptibly(int permits) 
//仅当调用时所有许可证都可用时，从该Semaphore中获取给定数量的许可证。
public boolean tryAcquire(int permits)
//如果在给定的等待时间内所有许可证都可用，并且当前线程未被中断，则从该Semaphore中获取给定数量的许可证。
public boolean tryAcquire(long timeout, TimeUnit unit)
//如果在给定的等待时间内所有许可证都可用，并且当前线程未被中断，则从该Semaphore中获取给定数量的许可证。
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
//释放指定数量的许可证，将其返回到Semaphore。
public void release(int permits) 
//返回此信号量中当前可用的许可证数。
public int availablePermits()
//获取和立即返回所有可用的许可证。
public int drainPermits() 
//缩减指定数量的许可证。
protected void reducePermits(int reduction)
//如果Semaphore设置为true,则返回true。
public boolean isFair()
//是否有线程正在等待获取许可证。
public final boolean hasQueuedThreads()
//返回正在等待的许可证数量。
public final int getQueueLength()
//返回所有等待获取许可证的线程集合。
protected Collection<Thread> getQueuedThreads()

4.案例

    Semaphore用于控制同时执行线程的数量，得到许可证的线程会得到执行，执行完成后释放许可证，之前没有获取许可证的线程将获取许可证。Semaphore比较适合用于一些流量控制的场景，尤其是公共资源有限的情况下，比如数据库连接等。

    固定线程池数量是15，执行的任务有10个，但是Semaphore（5）表示有5个线程可以获取许可证，最大并发量是5个线程，默认情况下Semaphore以非公平方式进行，获取许可证的线程将会得到执行，执行完成，通过release()释放许可证，其他线程将从Semaphore获取许可证后执行任务。

public class SemaphoreDemo {
  private static final int count = 10;
  private static ExecutorService exec = Executors.newFixedThreadPool(15);
  //使用Semaphore来限制流量，得到许可证的线程的到执行
  private static Semaphore semaphore = new Semaphore(5);
  public static void main(String[] args) {
    for(int i =0 ; i< count;i++) {
      exec.execute(new Runnable() {
        public void run() {
          try {
            //获取许可证
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+" executing....");
            TimeUnit.SECONDS.sleep(5);
            //释放许可证
            semaphore.release();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      });
    }
    exec.shutdown();
  }
}

执行结果如下，由于是非公平的Semaphore，无法保证获取许可证的顺序。

pool-1-thread-1 executing....
pool-1-thread-6 executing....
pool-1-thread-7 executing....
pool-1-thread-3 executing....
pool-1-thread-2 executing....
//后执行的5个任务
pool-1-thread-5 executing....
pool-1-thread-9 executing....
pool-1-thread-10 executing....
pool-1-thread-4 executing....
pool-1-thread-8 executing....