Semaphore

    Semaphore是JDK1.5位于java.util.concurrent包下的一个计数信号量。Semaphore通常用于限制可以访问某些资源的线程数目。它内部维护了一个许可集。在许可可用之前会阻塞每一个acquire()，然后再获取该许可；每个release()可以添加一个许可，从而可能释放一个正在阻塞的获得者。

 

    Semaphore有两个构造器，Semaphore(int permits)和Semaphore(int permits, boolean fair)，其中参数permits表示初始的可用许可数目；boolean值fair可以让我们选择是否接受一个公平的参数，为false时此类不对线程获取许可的顺序做任何保证，也就是说线程获取许可是随机的。为true时信号量保证对于任何调用获取方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。如果不设置的话默认为false。

 

    在Semaphore的所有方法中，acquire和release是最为重要的，两者都有重载方法。下面分别介绍其中的不同。

    acquire()：返回值为void。表示从此信号量获取一个许可，并将可用许可数减1。如果当前信号量没有许可可获取，线程将被阻塞，否则线程将被中断。

    acquire(int permits)：与acquire()不同的是此方法一次可以获取指定数目permits的许可，并将可用许可数减去permits。

    tryAcquire()：返回值为boolean。仅在调用此信号量存在一个可用许可时才从此信号量获取许可，并将可用许可数减1，同时返回true。如果没有可用的许可，此方法不会使线程阻塞，但是将立刻返回false。需要注意的是，此方法不使用公平设置，而是使用任意可用的许可，也就是说即使在构造器中设置了使用公平排序策略，但是调用此方法时也将立刻获取许可（如果有一个许可可用的话），而不管当前是否有正在等待的线程。

    tryAcquire(int permits)：与tryAcquire()一样，不过此方法允许获取多个许可。

    tryAcquire(long timeout, TimeUnit unit)：与tryAcquire()一样，不过此方法允许设置等待时间。如果超出等待时间则返回false。

    tryAcquire(int permits, long timeout, TimeUnit unit)：不再解释。

    release()：与acquire()对应，返回值为void。用于释放一个许可，并将其返回给信号量，同时将可用许可数加1。不要求释放许可的线程必须通过调用acquire来获取许可。如果任意线程试图获取许可，则选中一个线程并将刚刚释放的许可给予它。

    release(int permits)：与acquire(int permits)相对应，不解释。

 

    下面还是跟CyclicBarrier一样，举个吃饭的例子来体会Semaphore的用法。

    问题：假设“祥来饭店”只有5张桌子，这时候陆续来了8个人去该饭店吃饭（一个人一张桌），那些后来的顾客实在是不想走，因为该饭店做的东西真的是太好吃了，怎么办呢？只能等了。等待有桌子空闲了，他们才能开始享受美食的诱惑。而且要求先等待的先获取桌子的使用权。问，怎样用代码体现出来。

 

    对于上面的问题，可以创建一个Semaphore，参数permits为5，表示5张桌子。同时开启8个线程表示8位去此饭店吃饭的顾客。前5位顾客去的时候刚好有位置，也就是说都获得了桌子（许可），后面顾客来的时候桌子刚好满了（没许可了），此时他们只能排队等候（当试图获取许可的时候被阻塞了），直达有桌子空闲（许可被释放）。

 

    基于以上分析，代码如下：

package com.gk.thread.semaphore;

import java.util.concurrent.Semaphore;

public class Eat {
	
	public static void main(String[] args) throws InterruptedException {
		
		Semaphore sp = new Semaphore(5, true);			// 使用公平的排序
		
		Runnable r = new EatRunnable(sp);

		for (int i=1; i<=8; i++) {
			String name = "customer" + i;
			new Thread(r, name).start();
		}
		
	}

}

package com.gk.thread.semaphore;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Semaphore;

public class EatRunnable implements Runnable {

	private Semaphore sp;
	
	public EatRunnable(Semaphore sp) {
		this.sp = sp;
	}
	
	@Override
	public void run() {
		
		try {
			
			Thread.sleep((long)(Math.random() * 1000) * 10);		// 模拟先后到达饭店
			
			/*
			 * availablePermits()方法可以获取当前信号量中可用的许可数
			 */
			if (sp.availablePermits() <= 0) {	// 判断当前是否还有许可
				
				System.out.println("当前饭店已经没座位了，" + Thread.currentThread().getName() + "请排队等候...");
			}
			
			sp.acquire();	// 获取一个许可
			
			System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  -->  " + 
								Thread.currentThread().getName() + "来了======^_^======");
			
			Thread.sleep((long)(Math.random() * 1000) * 60);	// 模拟吃饭时间
			
			System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  -->  " + 
					Thread.currentThread().getName() + "走了...");
			
			sp.release();	// 释放许可
			
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
		
	}

}

    从运行结果可以看出，有8个线程同时执行，但是只有5个许可，所以多出来的3个只能排队等待了。当有线程释放了许可之后，按照线程排队等待的顺序，先等待的先获得许可往下执行。

    此外，基于Semaphore的特性，如果将信号量初始化为1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量。另请参见《同步之Semaphore信号量》。