信号量可以用来限制访问公共资源。在访问公共资源之前，线程必须从信号量获取许可。在访问资源之后，这个线程必须将许可返回给信号量，
为了创建信号量，必须使用可选的公平策略来确定许可的数量。任务通过调用信号量acquire（） 方法来获得许可，可通过调用信号量的release（）方法来释放许可。一旦获得许可，信号量中可用许可的数量减一。一旦许可呗释放掉，信号量的可用许可的总数加1。
使用只有一个许可的信号量可以模拟一个相互排斥的锁。
Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。自从5.0开始，jdk在java.util.concurrent包里提供了Semaphore 的官方实现，因此大家不需要自己去实现Semaphore。
下面的类使用信号量控制对内容池的访问：
import java.util.concurrent.Semaphore;
class Pool {
private static final int MAX_AVAILABLE = 100;
private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
public Object getItem() throws InterruptedException {
available.acquire(); // 从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断
return getNextAvailableItem();
}
public void putItem(Object x) {
if (markAsUnused(x))
available.release(); // 释放一个许可，将其返回给信号量
}
// 仅作示例参考，非真实数据
protected Object[] items = null;
protected 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;
}
}
虽然JDK已经提供了相关实现，但是还是很有必要去熟悉如何使用Semaphore及其背后的原理。
做一个简单的Semaphore实现：
class SemaphoreTest {
private boolean signal = false;
public synchronized void take() {
this.signal = true;
this.notify();
}
public synchronized void release() throws InterruptedException {
while (!this.signal)
wait();
this.signal = false;
}
}
使用这个semaphore可以避免错失某些信号通知。用take方法来代替notify，release方法来代替wait。如果某线程在调用release等待之前调用take方法，那么调用release方法的线程仍然知道take方法已经被某个线程调用过了，因为该Semaphore内部保存了take方法发出的信号。而wait和notify方法就没有这样的功能。
对于wait和notify方法，有两点必须要注意的：一，这两个方法是Object类的方法，也就是说Java中任何一个类都可以充当锁得角色；二，这两个方法必须放大synchronized 代码块里，以确保其执行时不受Java 多线程机制的影响。跟C写的信号量类比的话，wait 和 notify 相当于 block 和 wakeup ，而 synchronized 则确保wait 与 signal 方法的原子性。
可计数的Semaphore：
class SemaphoreTest {
private int signals = 0;
public synchronized void take() {
this.signals++;
this.notify();
}
public synchronized void release() throws InterruptedException {
while (this.signals == 0)
wait();
this.signals--;
}
}
Semaphore上限
：
class SemaphoreTest {
private int signals = 0;
private int bound = 0;
public SemaphoreTest(int upperBound) {
this.bound = upperBound;
}
public synchronized void take() throws InterruptedException {
while (this.signals == bound)
wait();
this.signals++;
this.notify();
}
public synchronized void release() throws InterruptedException {
while (this.signals == 0)
wait();
this.signals--;
this.notify();
}
}
当已经产生的信号数量达到了上限，take方法将阻塞新的信号产生请求，直到某个线程调用release方法后，被阻塞于take方法的线程才能传递自己的信号。
把Semaphore当锁来使用：
当信号量的数量上限是1时，Semaphore可以被当做锁来使用。通过take和release方法来保护关键区域。
避免死锁
有时两个或者多个线程需要在一个共享对象上获取锁，这可能导致死锁（Deadlock），也就是说，每个线程已经锁定一个对象，而且正在等待另一个对象。下面是一个很可能造成死锁的例子
import java.util.concurrent.*;
public class DeadlockTest
{
public static byte[] locker1 = new byte[0];
public static byte[] locker2 = new byte[0];
public static void main(String[] args)
{
ExecutorService executor = Executors.newFixedThreadPool(100);
for(int i =0 ;i <50;i++){
executor.execute(new DeadlockTask1());
executor.execute(new DeadlockTask2());
}
executor.shutdown();
while(!executor.isTerminated()){
}
System.exit(0);
}
private static class DeadlockTask1 implements Runnable
{
public void run()
{
synchronized(locker1){
System.out.println(" DeadlockTask1 获得锁 locker1 没有死锁！");
synchronized(locker2){
System.out.println(" DeadlockTask1 获得锁 locker2 没有死锁！");
}
}
}
}
private static class DeadlockTask2 implements Runnable
{
public void run()
{
synchronized(locker2){
System.out.println(" DeadlockTask2 获得锁 locker2 没有死锁！");
synchronized(locker1){
System.out.println(" DeadlockTask2 获得锁 locker1 没有死锁！");
}
}
}
}
}
但是使用资源排序技术就可以轻易的避免死锁的发生。原理就是为每一个需要锁的对象排序，确保每个线程都按照这个顺序来获取锁。假设，按照locker1、locker2的顺序对连个对象排序。采用资源排序技术，线程2必须先获得locker1上的锁，然后才能获取lock2上面的锁。一旦线程1 获取的locker1上的锁，线程2必须等待locker1的锁。所以不会在发生死锁现象。
import java.util.concurrent.*;
public class DeadlockTest
{
public static byte[] locker1 = new byte[0];
public static byte[] locker2 = new byte[0];
public static void main(String[] args)
{
ExecutorService executor = Executors.newFixedThreadPool(100);
for(int i =0 ;i <50;i++){
executor.execute(new DeadlockTask1());
executor.execute(new DeadlockTask2());
}
executor.shutdown();
while(!executor.isTerminated()){
}
System.exit(0);
}
private static class DeadlockTask1 implements Runnable
{
public void run()
{
synchronized(locker1){
System.out.println(" DeadlockTask1 获得锁 locker1 没有死锁！");
synchronized(locker2){
System.out.println(" DeadlockTask1 获得锁 locker2 没有死锁！");
}
}
}
}
private static class DeadlockTask2 implements Runnable
{
public void run()
{
synchronized(locker1){
System.out.println(" DeadlockTask2 获得锁 locker2 没有死锁！");
synchronized(locker2){
System.out.println(" DeadlockTask2 获得锁 locker1 没有死锁！");
}
}
}
}
}
参考出处：
http://cuisuqiang.iteye.com/blog/2020146
参考出处：http://www.cnblogs.com/duanjie/archive/2012/05/05/2489177.html
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/13751.html