线程间控制之Semaphore使用介绍

        Semaphore（信号量）通常用于限制访问某些(物理或逻辑)资源线程的数量。

        一个信号量维护一组许可证。每个acquire()都会阻塞，直到获得许可证；每个release()会释放许可证。如果没有线程需要获取许可证；信号量只是像其它池对象那样保持一个可用许可证的计数。

        池对象：线程池、数据库连接池等，创建一个池子，池子中已经建立好了连接，需要使用的时候直接从池子中拿来用。

一、Pool类源代码

        例子，这里有一个Pool类，它使用信号量来控制对项目池的访问

package ThreadStudy;

import java.util.concurrent.Semaphore;
//信号量通常用于限制访问某些(物理或逻辑)资源线程的数量
public class Pool {
	private final static int MAX_AVAILABLE = 100;
	//创建一个具有100许可证的信号量，采用公平方式获取许可证
	private final Semaphore semaphore = new Semaphore(MAX_AVAILABLE, true);

	public Object getItem() throws Exception {
		semaphore.acquire();
		return getNextAvailableItem();
	}

	public void putItem(Object x) {
		if (markAsUnused(x)) {
			semaphore.release();
		}
	}
	// 管理的任何类型的项目
	Object[] items = new Object[MAX_AVAILABLE];
	boolean[] used = new boolean[MAX_AVAILABLE];

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

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

二、二进制信号量用法

        一个初始化为1的信号量，并且它最多只能有一个permit可用，可以作为互斥锁。这通常被称为二进制信号量，因为它只有两种状态:一个可用的许可证，或零可用的许可证。当以这种方式使用时，二进制信号量具有这样的属性(与许多锁实现不同)，即“锁”可以由所有者以外的线程释放(因为信号量没有所有权的概念)。这在某些特定的上下文中可能很有用，比如死锁恢复。

package ThreadStudy;

import java.util.concurrent.Semaphore;

public class SemaphoreT2 {
	public static void main(String[] args) throws Exception {
		Semaphore semophore = new Semaphore(1);
		semophore.acquire();
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					// 获取不到许可证，线程阻塞
					System.out.println(Thread.currentThread().getName()+"获取不到许可证，线程阻塞");
					semophore.acquire();
					System.out.println(Thread.currentThread().getName()+"获取到许可证，线程继续执行");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					// 释放许可证
					System.out.println(Thread.currentThread().getName()+"释放许可证");
					Thread.sleep(3000);
					semophore.release();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();

	}
}

三、Semaphore类中各种方法使用介绍

        1、俩个构造方法的区别，公平非公平！

        2、普通方法

        3、代码示例

package ThreadStudy;

import java.util.concurrent.Semaphore;

public class SemaphoreT1 {
	public static void main(String[] args) {
		int MAX = 10;
		// 创建10个许可证
		Semaphore s = new Semaphore(MAX);
		for (int i = 0; i < MAX; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {

						System.out.println("等待获取许可证的线程数量评估值：" + s.getQueueLength());
						// 获取二个许可证
						s.acquire(2);
						
						System.out.println("返回此信号量中可用的当前许可数，此方法通常用于调试和测试目的:" + s.availablePermits());
						System.out.println("获取并返回所有立即可用的许可:" + s.drainPermits());
						// 和acquire的唯一区别就是，一直处于阻塞状态，除了获取到一个许可证
						s.acquireUninterruptibly();

						// 获取许可证，并且返回true，便于代码流程控制
						if (s.tryAcquire()) {
							System.out.println("tryAcquire返回为true");
						} else {
							System.out.println("tryAcquire返回为false");
						}
						Thread.sleep(1000);
						// 获取一个许可证
						s.acquire();
						// 获取5个许可证
						s.acquire(5);

						System.out.println("线程获取到许可：" + Thread.currentThread().getName());
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}).start();
		}
	}
}