关闭

java中的信号量Semaphore

标签: javasemaphore
625人阅读 评论(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
查看评论

Java中的信号量Semaphore

参考资料: 1. http://blog.csdn.net/zmx729618/article/details/51593666 2. jdk官方文档java提供了一个类Semaphore来实现信号量,概念上讲,一个信号量相当于持有一些许可(permits),线程可以调用Semaphore对象的...
  • zlp1992
  • zlp1992
  • 2016-09-30 10:10
  • 2143

Java中Semaphore(信号量)的使用

Semaphore的作用:在java中,使用了synchronized关键字和Lock锁实现了资源的并发访问控制,在同一时间只允许唯一了线程进入临界区访问资源(读锁除外),这样子控制的主要目的是为了解决多个线程并发同一资源造成的数据不一致的问题。在另外一种场景下,一个资源有多个副本可供同时使用,比如...
  • zbc1090549839
  • zbc1090549839
  • 2016-11-29 10:30
  • 7252

java Semaphore信号量的原理和示例

Semaphore简介Semaphore是一个计数信号量,它的本质是一个”共享锁”。信号量维护了一个信号量许可集。线程可以通过调用acquire()来获取信号量的许可;当信号量中有可用的许可时,线程能获取该许可;否则线程必须等待,直到有可用的许可为止。 线程可以通过release()来释放它所持有的...
  • qilixiang012
  • qilixiang012
  • 2015-04-21 20:57
  • 2863

java中的计数信号量(Counting Semaphore)

信号量(Semaphore)又称为信号量、旗语,它以一个整数变数,提供信号,以确保在并行计算环境中,不同进程在访问共享资源时,不会发生冲突。是一种不需要使用忙碌等待(busy waiting)的一种方法。 信号量的概念是由荷兰计算机科学家艾兹格·迪杰斯特拉(Edsger W. Dijkst...
  • mhmyqn
  • mhmyqn
  • 2015-08-29 19:38
  • 2669

java中的信号量semaphore实现生产者消费者模式

Semaphore 信号量,就是一个允许实现设置好的令牌。也许有1个,也许有10个或更多。  谁拿到令牌(acquire)就可以去执行了,如果没有令牌则需要等待。  执行完毕,一定要归还(release)令牌,否则令牌会被很快用光,别的线程就无法获得令牌而执行下去了。 ...
  • mm_bit
  • mm_bit
  • 2015-11-24 11:59
  • 2403

java线程同步的三种方法[synchronized关键字,Lock加锁,信号量Semaphore]

java多线程的难点是在:处理多个线程同步与并发运行时线程间的通信问题。java在处理线程同步时,常用方法有: 1、synchronized关键字。 2、Lock显示加锁。 3、信号量Semaphore。   线程同步问题引入:     ...
  • zmx729618
  • zmx729618
  • 2017-04-01 15:10
  • 647

Java并发之Semaphore详解

一、入题        Semaphore是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做完自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连...
  • lipeng_bigdata
  • lipeng_bigdata
  • 2016-08-09 20:51
  • 15167

比较ReentrantLock和synchronized和信号量Semaphore实现的同步性能

为了比较一下ReentrantLock和synchronized的性能,做了一下性能测试: public class ReentreLockTest { private static long COUNT = 1000000; private static Lock lock ...
  • arkblue
  • arkblue
  • 2011-01-14 14:21
  • 6910

Java中的Semaphore和Lock区别

Java提供了一个类Semaphore来实现信号量,概念上讲,一个信号量相当于持有一些许可(permits),线程可以调用Semaphore对象的acquire()方法获取一个许可,调用release()来归还一个许可 1 构造方法:  Semaphore有两个构造方法 ...
  • gengyiping18
  • gengyiping18
  • 2017-03-03 16:38
  • 1586

Java: 使用信号量(Semaphore)保护多个共享资源的访问

信号量(semaphore)机制是一种常用的同步机制,在现代OS中被广泛采用。semaphore是一个非0值,当它的值大于0时表示系统目前还有足够的资源分配给请求线程,每分配出去一个资源,值递减。当值等于0时表示当前已无资源可分配。JDK提供了Semaphore类来实现信号量。假如我们一共有3台打印...
  • tracker_w
  • tracker_w
  • 2015-03-26 11:36
  • 1523
    个人资料
    • 访问:270397次
    • 积分:3124
    • 等级:
    • 排名:第13171名
    • 原创:89篇
    • 转载:55篇
    • 译文:0篇
    • 评论:39条