Semaphore的介绍和使用

http://wosyingjun.iteye.com/blog/2299860

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。拿到信号量的线程可以进入代码，否则就等待。通过acquire()和release()获取和释放访问许可。

 

Semaphore类位于java.util.concurrent包下，它提供了2个构造器：

Java代码  

1. //参数permits表示许可数目，即同时可以允许多少线程进行访问  
2. public Semaphore(int permits) {  
3.     sync = new NonfairSync(permits);  
4. }  
5. //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可  
6. public Semaphore(int permits, boolean fair) {  
7.     sync = (fair)? new FairSync(permits) : new NonfairSync(permits);  
8. }  

 

 

Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：

acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。

release()用来释放许可。注意，在释放许可之前，必须先获获得许可。

Java代码  

1. public void acquire() throws InterruptedException {  }     //获取一个许可  
2. public void acquire(int permits) throws InterruptedException { }    //获取permits个许可  
3. public void release() { }          //释放一个许可  
4. public void release(int permits) { }    //释放permits个许可  

 

 

这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

Java代码  

1. //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false  
2. public boolean tryAcquire() { };  
3. //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false  
4. public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };   
5. //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false  
6. public boolean tryAcquire(int permits) { };   
7. //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true  
8. public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { };  
9. //得到当前可用的许可数目  
10. public int availablePermits();  

 

 

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现：

Java代码  

1. public class Test {  
2.     public static void main(String[] args) {  
3.         int N = 8; //工人数  
4.         Semaphore semaphore = new Semaphore(5); //机器数目  
5.         for(int i=0;i<N;i++)  
6.             new Worker(i,semaphore).start();  
7.     }      
8.     static class Worker extends Thread{  
9.         private int num;  
10.         private Semaphore semaphore;  
11.         public Worker(int num,Semaphore semaphore){  
12.             this.num = num;  
13.             this.semaphore = semaphore;  
14.         }          
15.         @Override  
16.         public void run() {  
17.             try {  
18.                 semaphore.acquire();  
19.                 System.out.println("工人"+this.num+"占用一个机器在生产...");  
20.                 Thread.sleep(2000);  
21.                 System.out.println("工人"+this.num+"释放出机器");  
22.                 semaphore.release();              
23.             } catch (InterruptedException e) {  
24.                 e.printStackTrace();  
25.             }  
26.         }  
27.     }  
28. }  

 

运行结果：

Java代码  

1. 工人0占用一个机器在生产...  
2. 工人1占用一个机器在生产...  
3. 工人2占用一个机器在生产...  
4. 工人4占用一个机器在生产...  
5. 工人5占用一个机器在生产...  
6. 工人0释放出机器  
7. 工人2释放出机器  
8. 工人3占用一个机器在生产...  
9. 工人7占用一个机器在生产...  
10. 工人4释放出机器  
11. 工人5释放出机器  
12. 工人1释放出机器  
13. 工人6占用一个机器在生产...  
14. 工人3释放出机器  
15. 工人7释放出机器  
16. 工人6释放出机器