計數信號量用來控制同時訪問某個特定資源的操作數或同時執行某個指定操作的數量

A counting semaphore.Conceptually, a semaphore maintains a set of permits. Each acquire blocks if necessary until a permit is available, and then takes it. Each release adds a permit, potentially releasing a blocking acquirer. However, no actual permit objects are used; the Semaphore just keeps a count of the number available and acts accordingly.

從概念上來說，Semaphore中維護了一組許可，許可的數量在構造函數中指定。acquire方法將獲取一個可用的許可，如果沒有可用的許可，該方法會被阻塞，直到Semaphore中有可用的許可。release方法釋放一個許可，如果此時存在阻塞中的acqure方法，將釋放一個阻塞中的acquire

事實上，Semaphore中只維護可用請求數量，並不包含實際的請求對象

示例一：數據庫連接池

在初始化Semaphore時可以設置其公平性，如果為公平Semaphore，則按照請求時間獲得許可，即先發送的請求先獲得許可，如果為非公平Semaphore，則先發送的請求未必先獲得許可，這有助於提高程序的吞吐量，但是有可能導致某些請求始終獲取不到許可（tryAcquire方法不使用公平性設置）

1. import java.sql.Connection;
2. import java.sql.DriverManager;
3. import java.util.HashMap;
4. import java.util.LinkedList;
5. import java.util.Map;
6. import java.util.concurrent.Semaphore;
8. public class MyConnPool {
9. private LinkedList<Connection> unusedConns =
10. new LinkedList<Connection>();
11. //釋放連接時對查找性能要求較高，故使用哈希表
12. private Map<Connection,String> usedConns =
13. new HashMap<Connection,String>();
14. private final Semaphore available;
16. public MyConnPool(int size) throws Exception{
17. StringBuilder builder = new StringBuilder();
18. builder.append("-----pool-----\n");
19. available = new Semaphore(size, true);//公平性Semaphore
20. String url = "jdbc:mysql://ip:port/name?user=user&password=pwd";
21. for(int i = 0 ; i < size ; i++){
22. Connection conn = DriverManager.getConnection(url);
23. unusedConns.add(conn);
24. builder.append("conn-" + i + ":" + conn.hashCode() + "\n");
25. }
26. builder.append("--------------\n");
27. System.out.print(builder.toString());
28. }
30. public Connection getConn() throws InterruptedException{
31. //獲取Semaphore中的許可
32. available.acquire();
33. Connection conn = null;
34. synchronized(this){
35. conn = unusedConns.removeFirst();
36. usedConns.put(conn, "");
38. System.out.println(Thread.currentThread().getName()
39. + ":" + conn.hashCode() + "[got]");
40. System.out.println(display());
41. }
42. return conn;
43. }
45. public void close(Connection conn){
46. synchronized(this){
47. if(usedConns.containsKey(conn)){
48. usedConns.remove(conn);
49. unusedConns.addLast(conn);
51. System.out.println(Thread.currentThread().getName()
52. + ":" + conn.hashCode() + "[closed]");
53. System.out.println(display());
54. }
55. }
56. //釋放線程獲取的許可
57. available.release();
58. }
60. private final synchronized String display(){
61. String str = "";
62. if(unusedConns.size() > 0){
63. str = "";
64. for(Connection conn : unusedConns){
65. str += conn.hashCode() + "|";
66. }
67. }
68. if(!str.equals(""))
69. return str;
70. else
71. return "empty";
72. }
73. }

1. import java.sql.Connection;
2. import java.util.concurrent.CountDownLatch;
4. public class Test implements Runnable{
5. private static CountDownLatch latch
6. = new CountDownLatch(1);
7. private MyConnPool pool;
9. public Test(MyConnPool pool){
10. this.pool = pool;
11. }
13. @Override
14. public void run(){
15. try {
16. latch.await();
17. Connection conn = pool.getConn();
18. Thread.sleep(1*1000);
19. pool.close(conn);
20. } catch (InterruptedException e) {
21. e.printStackTrace();
22. }
23. }
25. public static void main(String[] args) throws Exception{
26. MyConnPool pool = new MyConnPool(2);
27. for(int i = 0 ; i < 4 ; i++){
28. Thread t = new Thread(new Test(pool));
29. t.start();
30. }
31. //保證4個線程同時運行
32. latch.countDown();
33. }
34. }

運行結果如下：

1. -----pool-----
2. conn-0:11631043
3. conn-1:14872264
4. --------------
5. Thread-4:11631043[got]
6. 14872264|
7. Thread-1:14872264[got]
8. empty
9. Thread-4:11631043[closed]
10. 11631043|
11. Thread-2:11631043[got]
12. empty
13. Thread-1:14872264[closed]
14. 14872264|
15. Thread-3:14872264[got]
16. empty
17. Thread-2:11631043[closed]
18. 11631043|
19. Thread-3:14872264[closed]
20. 11631043|14872264|

特別註意如果getConn方法和close方法都為同步方法，將產生死鎖：

1. public synchronized Connection getConn() throws InterruptedException{
2. ......
3. }
5. public synchronized void close(Connection conn){
6. ......
7. }

同一時刻只能有一個線程調用連接池的getConn方法或close方法，當Semaphore中沒有可用的許可，並且此時恰好有一個線程成功調用連接池的getConn方法，則該線程將一直阻塞在acquire方法上，其它線程將沒有辦法獲取連接池上的鎖並調用close方法釋放許可，程序將會卡死

阻塞方法上不要加鎖，否則將導致鎖長時間不釋放，如果該鎖為互斥鎖，將導致程序卡住

acquire方法本身使用樂觀鎖實現，也不需要再加互斥鎖

示例二：不可重入互斥鎖

1. import java.util.concurrent.CountDownLatch;
2. import java.util.concurrent.Semaphore;
4. public class Test implements Runnable{
5. private static CountDownLatch latch =
6. new CountDownLatch(1);
7. private static Semaphore lock =
8. new Semaphore(1, true);
10. @Override
11. public void run(){
12. try {
13. latch.await();
14. this.work();
15. } catch (InterruptedException e) {
16. e.printStackTrace();
17. }
18. }
20. private void work() throws InterruptedException{
21. lock.acquire();
22. System.out.println("Locking by "
23. + Thread.currentThread().getName());
24. Thread.sleep(1*1000);
25. lock.release();
26. }
28. public static void main(String[] args) throws Exception{
29. for(int i = 0 ; i < 4 ; i++){
30. Thread t = new Thread(new Test());
31. t.start();
32. }
33. //保證4個線程同時運行
34. latch.countDown();
35. }
36. }

運行結果如下：

1. Locking by Thread-3
2. Locking by Thread-0
3. Locking by Thread-1
4. Locking by Thread-2

Java中Semaphore(信號量) 數據庫連接池