JAVA并发信号量 Semaphore

转载自http://qindongliang.iteye.com/blog/2017276

Semaphore当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

Java代码  

1. package com.test;  
2.   
3. import java.util.concurrent.ExecutorService;  
4.   
5. import java.util.concurrent.Executors;  
6.   
7. import java.util.concurrent.Semaphore;  
8.   
9. public class TestSemaphore {  
10.   
11.                 public static void main(String[] args) {  
12.   
13.                 // 线程池  
14.   
15.                 ExecutorService exec = Executors.newCachedThreadPool();  
16.   
17.                 // 只能5个线程同时访问  
18.   
19.                 final Semaphore semp = new Semaphore(5);  
20.   
21.                  // 模拟20个客户端访问  
22.   
23.                  for (int index = 0; index < 20; index++) {  
24.   
25.                               final int NO = index;  
26.   
27.                               Runnable run = new Runnable() {  
28.   
29.                                                  public void run() {  
30.   
31.                                                             try {  
32.   
33.                                                                     // 获取许可  
34.   
35.                                                                     semp.acquire();  
36.   
37.                                                                     System.out.println("Accessing: " + NO);  
38.   
39.                                                                     Thread.sleep((long) (Math.random() * 10000));  
40.   
41.                                                                     // 访问完后，释放  
42.   
43.                                                                     semp.release();  
44.   
45.                                                                     System.out.println("-----------------"+semp.availablePermits());  
46.   
47.                                                             } catch (InterruptedException e) {  
48.   
49.                                                                     e.printStackTrace();  
50.   
51.                                                             }  
52.   
53.                                                   }  
54.   
55.                                       };  
56.   
57.                       exec.execute(run);  
58.   
59.              }  
60.   
61.              // 退出线程池  
62.   
63.              exec.shutdown();  
64.   
65.        }  
66.   
67. }   

执行结果如下：

Java代码  

1. Accessing: 0  
2.   
3. Accessing: 1  
4.   
5. Accessing: 3  
6.   
7. Accessing: 4  
8.   
9. Accessing: 2  
10.   
11. -----------------0  
12.   
13. Accessing: 6  
14.   
15. -----------------1  
16.   
17. Accessing: 7  
18.   
19. -----------------1  
20.   
21. Accessing: 8  
22.   
23. -----------------1  
24.   
25. Accessing: 10  
26.   
27. -----------------1  
28.   
29. Accessing: 9  
30.   
31. -----------------1  
32.   
33. Accessing: 5  
34.   
35. -----------------1  
36.   
37. Accessing: 12  
38.   
39. -----------------1  
40.   
41. Accessing: 11  
42.   
43. -----------------1  
44.   
45. Accessing: 13  
46.   
47. -----------------1  
48.   
49. Accessing: 14  
50.   
51. -----------------1  
52.   
53. Accessing: 15  
54.   
55. -----------------1  
56.   
57. Accessing: 16  
58.   
59. -----------------1  
60.   
61. Accessing: 17  
62.   
63. -----------------1  
64.   
65. Accessing: 18  
66.   
67. -----------------1  
68.   
69. Accessing: 19