投稿
  1. 云图网首页
  2. 业界资讯

java中的信号量Semaphore详解编程语言

• 业界资讯

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

  java中的信号量Semaphore详解编程语言

        为了创建信号量，必须使用可选的公平策略来确定许可的数量。任务通过调用信号量acquire（） 方法来获得许可，可通过调用信号量的release（）方法来释放许可。一旦获得许可，信号量中可用许可的数量减一。一旦许可呗释放掉，信号量的可用许可的总数加1。

     java中的信号量Semaphore详解编程语言

        使用只有一个许可的信号量可以模拟一个相互排斥的锁。

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 没有死锁！"); 
				} 
			} 
		} 
	} 
}

java中的信号量Semaphore详解编程语言

 但是使用资源排序技术就可以轻易的避免死锁的发生。原理就是为每一个需要锁的对象排序，确保每个线程都按照这个顺序来获取锁。假设，按照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

赞 (0)
0 0
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论