溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這是java高并發系列第15篇文章
Semaphore（信號量）為多線程協作提供了更為強大的控制方法，前面的文章中我們學了synchronized和重入鎖ReentrantLock，這2種鎖一次都只能允許一個線程訪問一個資源，而信號量可以控制有多少個線程可以同時訪問特定的資源。
Semaphore常用場景：限流
舉個例子：
比如有個停車場，有5個空位，門口有個門衛，手中5把鑰匙分別對應5個車位上面的鎖，來一輛車，門衛會給司機一把鑰匙，然后進去找到對應的車位停下來，出去的時候司機將鑰匙歸還給門衛。停車場生意比較好，同時來了100兩車，門衛手中只有5把鑰匙，同時只能放5輛車進入，其他車只能等待，等有人將鑰匙歸還給門衛之后，才能讓其他車輛進入。
上面的例子中門衛就相當于Semaphore，車鑰匙就相當于許可證，車就相當于線程。
Semaphore(int permits)：構造方法，參數表示許可證數量，用來創建信號量
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公眾號：javacode2018，獲取年薪50萬課程
*/
public class Demo1 {
static Semaphore semaphore = new Semaphore(2);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
try {
semaphore.acquire();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",獲取許可!");
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",釋放許可!");
}
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new T("t-" + i).start();
}
}
}輸出：
1563715791327,t-0,獲取許可!
1563715791327,t-1,獲取許可!
1563715794328,t-0,釋放許可!
1563715794328,t-5,獲取許可!
1563715794328,t-1,釋放許可!
1563715794328,t-2,獲取許可!
1563715797328,t-2,釋放許可!
1563715797328,t-6,獲取許可!
1563715797328,t-5,釋放許可!
1563715797328,t-3,獲取許可!
1563715800329,t-6,釋放許可!
1563715800329,t-9,獲取許可!
1563715800329,t-3,釋放許可!
1563715800329,t-7,獲取許可!
1563715803330,t-7,釋放許可!
1563715803330,t-8,獲取許可!
1563715803330,t-9,釋放許可!
1563715803330,t-4,獲取許可!
1563715806330,t-8,釋放許可!
1563715806330,t-4,釋放許可!代碼中new Semaphore(2)創建了許可數量為2的信號量，每個線程獲取1個許可，同時允許兩個線程獲取許可，從輸出中也可以看出，同時有兩個線程可以獲取許可，其他線程需要等待已獲取許可的線程釋放許可之后才能運行。為獲取到許可的線程會阻塞在acquire()方法上，直到獲取到許可才能繼續。
門衛（Semaphore）有點呆，司機進去的時候給了鑰匙，出來的時候不歸還，門衛也不會說什么。最終結果就是其他車輛都無法進入了。
如下代碼：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公眾號：javacode2018，獲取年薪50萬課程
*/
public class Demo2 {
static Semaphore semaphore = new Semaphore(2);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
try {
semaphore.acquire();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",獲取許可!");
TimeUnit.SECONDS.sleep(3);
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",運行結束!");
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",當前可用許可數量:" + semaphore.availablePermits());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new T("t-" + i).start();
}
}
}輸出：
1563716603924,t-0,獲取許可!
1563716603924,t-1,獲取許可!
1563716606925,t-0,運行結束!
1563716606925,t-0,當前可用許可數量:0
1563716606925,t-1,運行結束!
1563716606925,t-1,當前可用許可數量:0上面程序運行后一直無法結束，觀察一下代碼，代碼中獲取許可后，沒有釋放許可的代碼，最終導致，可用許可數量為0，其他線程無法獲取許可，會在semaphore.acquire();處等待，導致程序無法結束。
示例1中，在finally里面釋放鎖，會有問題么？
如果獲取鎖的過程中發生異常，導致獲取鎖失敗，最后finally里面也釋放了許可，最終會怎么樣，導致許可數量憑空增長了。
示例代碼：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公眾號：javacode2018，獲取年薪50萬課程
*/
public class Demo3 {
static Semaphore semaphore = new Semaphore(1);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
try {
semaphore.acquire();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",獲取許可,當前可用許可數量:" + semaphore.availablePermits());
//休眠100秒
TimeUnit.SECONDS.sleep(100);
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",運行結束!");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",當前可用許可數量:" + semaphore.availablePermits());
}
}
public static void main(String[] args) throws InterruptedException {
T t1 = new T("t1");
t1.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t2 = new T("t2");
t2.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t3 = new T("t3");
t3.start();
//給t2和t3發送中斷信號
t2.interrupt();
t3.interrupt();
}
}輸出：
1563717279058,t1,獲取許可,當前可用許可數量:0
java.lang.InterruptedException
1563717281060,t2,當前可用許可數量:1
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)
1563717281060,t3,當前可用許可數量:2
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)程序中信號量許可數量為1，創建了3個線程獲取許可，線程t1獲取成功了，然后休眠100秒。其他兩個線程阻塞在semaphore.acquire();方法處，代碼中對線程t2、t3發送中斷信號，我們看一下Semaphore中acquire的源碼：
public void acquire() throws InterruptedException這個方法會響應線程中斷，主線程中對t2、t3發送中斷信號之后，acquire()方法會觸發InterruptedException異常，t2、t3最終沒有獲取到許可，但是他們都執行了finally中的釋放許可的操作，最后導致許可數量變為了2，導致許可數量增加了。所以程序中釋放許可的方式有問題。需要改進一下，獲取許可成功才去釋放鎖。
正確的釋放鎖的方式，如下：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公眾號：javacode2018，獲取年薪50萬課程
*/
public class Demo4 {
static Semaphore semaphore = new Semaphore(1);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
//獲取許可是否成功
boolean acquireSuccess = false;
try {
semaphore.acquire();
acquireSuccess = true;
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",獲取許可,當前可用許可數量:" + semaphore.availablePermits());
//休眠100秒
TimeUnit.SECONDS.sleep(5);
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",運行結束!");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (acquireSuccess) {
semaphore.release();
}
}
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",當前可用許可數量:" + semaphore.availablePermits());
}
}
public static void main(String[] args) throws InterruptedException {
T t1 = new T("t1");
t1.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t2 = new T("t2");
t2.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t3 = new T("t3");
t3.start();
//給t2和t3發送中斷信號
t2.interrupt();
t3.interrupt();
}
}輸出：
1563717751655,t1,獲取許可,當前可用許可數量:0
1563717753657,t3,當前可用許可數量:0
java.lang.InterruptedException
1563717753657,t2,當前可用許可數量:0
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)
1563717756656,t1,運行結束!
1563717756656,t1,當前可用許可數量:1程序中增加了一個變量acquireSuccess用來標記獲取許可是否成功，在finally中根據這個變量是否為true，來確定是否釋放許可。
司機來到停車場，發現停車場已經滿了，只能在外等待內部的車出來之后才能進去，但是要等多久，他自己也不知道，他希望等10分鐘，如果還是無法進去，就不到這里停車了。
Semaphore內部2個方法可以提供超時獲取許可的功能：
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
throws InterruptedException 在指定的時間內去嘗試獲取許可，如果能夠獲取到，返回true，獲取不到返回false。
示例代碼：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公眾號：javacode2018，獲取年薪50萬課程
*/
public class Demo5 {
static Semaphore semaphore = new Semaphore(1);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
//獲取許可是否成功
boolean acquireSuccess = false;
try {
//嘗試在1秒內獲取許可，獲取成功返回true，否則返回false
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",嘗試獲取許可,當前可用許可數量:" + semaphore.availablePermits());
acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);
//獲取成功執行業務代碼
if (acquireSuccess) {
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",獲取許可成功,當前可用許可數量:" + semaphore.availablePermits());
//休眠5秒
TimeUnit.SECONDS.sleep(5);
} else {
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",獲取許可失敗,當前可用許可數量:" + semaphore.availablePermits());
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (acquireSuccess) {
semaphore.release();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
T t1 = new T("t1");
t1.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t2 = new T("t2");
t2.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t3 = new T("t3");
t3.start();
}
}輸出：
1563718410202,t1,嘗試獲取許可,當前可用許可數量:1
1563718410202,t1,獲取許可成功,當前可用許可數量:0
1563718411203,t2,嘗試獲取許可,當前可用許可數量:0
1563718412203,t3,嘗試獲取許可,當前可用許可數量:0
1563718412204,t2,獲取許可失敗,當前可用許可數量:0
1563718413204,t3,獲取許可失敗,當前可用許可數量:0代碼中許可數量為1，semaphore.tryAcquire(1, TimeUnit.SECONDS);：表示嘗試在1秒內獲取許可，獲取成功立即返回true，超過1秒還是獲取不到，返回false。線程t1獲取許可成功，之后休眠了5秒，從輸出中可以看出t2和t3都嘗試了1秒，獲取失敗。
throws InterruptedException聲明的，表示這個方法會響應線程中斷信號，什么意思？表示調用線程的interrupt()方法，會讓這些方法觸發InterruptedException異常，即使這些方法處于阻塞狀態，也會立即返回，并拋出InterruptedException異常，線程中斷信號也會被清除。java高并發系列連載中，總計估計會有四五十篇文章，可以關注公眾號：javacode2018，獲取最新文章。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
