关闭

java中的信号量Semaphore

标签: javasemaphore
412人阅读 评论(0) 收藏 举报
分类:

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

  

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

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:157374次
    • 积分:2379
    • 等级:
    • 排名:第15660名
    • 原创:89篇
    • 转载:55篇
    • 译文:0篇
    • 评论:25条
    最新评论