java中的信号量Semaphore

信号量可以用来限制访问公共资源。在访问公共资源之前，线程必须从信号量获取许可。在访问资源之后，这个线程必须将许可返回给信号量，

  

        为了创建信号量，必须使用可选的公平策略来确定许可的数量。任务通过调用信号量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