自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

Java并發(fā)編程（JUC）模擬AND型信號量

作者：李子樹_
開發(fā) 后端
AND型信號量可能大家都聽說過并可能都有一定的理解，但是你有使用過么?今天就使用Java來模擬實現(xiàn)!

AND型信號量可能大家都聽說過并可能都有一定的理解，但是你有使用過么?今天就使用Java來模擬實現(xiàn)!

[[282783]]

本文是對上篇文章(進程同步機制)的一次實踐，通過JUC提供的一些機制來模擬一些OS中的AND型信號量，因為記錄型型信號量可以等價于JUC中提供的Semaphore(信號量)，但是對于AND型信號量因為一些原因(主要是過時了)，JUC沒有提供，今天就手動的來寫一個AND型信號量對應(yīng)的Swait操作和Ssignal操作(這里不明白的可以看前面的理論篇)。通過本篇博文讓你對進程同步機制有個更好的理解。

1.一個錯誤示例

在這里，首先解釋一下，為了滿足線程申請信號量不成功后將進程阻塞，并插入到對應(yīng)的隊列中，所以使用了ReentrantLock+Condition來實現(xiàn)Swait方法。廢話不多說，直接上代碼：

  1. //數(shù)據(jù)定義 
  2.  
  3. static Lock lock = new ReentrantLock(); 
  4.  
  5. static Condition condition1 = lock.newCondition(); 
  6.  
  7. static Condition condition2 = lock.newCondition(); 
  8.  
  9. public static void Swait(String id, Semaphore s1, Semaphore s2) throws InterruptedException { 
  10.  
  11. lock.tryLock(1, TimeUnit.SECONDS); 
  12.  
  13. log.info("當前的兩個信號量的狀態(tài)：【{},{}】", s1.availablePermits(), s2.availablePermits()); 
  14.  
  15. //availablePermits可獲取到信號量中還剩余的值 
  16.  
  17. if(s1.availablePermits() < 1 || s2.availablePermits() < 1){ 
  18.  
  19. if (s1.availablePermits() < 1) { 
  20.  
  21. log.info("線程【{}】被掛起到信號量【{}】中", id, s1); 
  22.  
  23. //阻塞，并插入到condition1的阻塞隊列中 
  24.  
  25. condition1.await(); 
  26.  
  27. } else { 
  28.  
  29. log.info("線程【{}】被掛起到信號量【{}】中", id, s2); 
  30.  
  31. //阻塞，并插入到condition2的阻塞隊列中 
  32.  
  33. condition2.await(); 
  34.  
  35. } 
  36.  
  37. log.info("被掛起的線程【{}】被喚醒執(zhí)行。", id); 
  38.  
  39. } else { 
  40.  
  41. log.info("為線程【{}】分配資源！", id); 
  42.  
  43. s1.acquire(); 
  44.  
  45. s2.acquire(); 
  46.  
  47. } 
  48.  
  49. lock.unlock(); 
  50.  
  51. } 
  52.  
  53. public static void Ssignal(Semaphore s1, Semaphore s2) throws InterruptedException { 
  54.  
  55. log.info("線程【{}】執(zhí)行了釋放資源", id); 
  56.  
  57. lock.tryLock(1, TimeUnit.SECONDS); 
  58.  
  59. s1.release(); 
  60.  
  61. s2.release(); 
  62.  
  63. //喚醒等待隊列中的線程 
  64.  
  65. condition.signal(); 
  66.  
  67. lock.unlock(); 
  68.  
  69. } 

​ 大家仔細看上面的代碼，這個也是我剛開始寫的代碼，第一眼看似乎是沒什么問題，但是里面隱藏著一個坑，在Swait方法中，調(diào)用condition1.await()，此時線程被阻塞在這一行中，但是當被別的線程(調(diào)用Ssignal)喚醒時，在被阻塞的下一行開始繼續(xù)執(zhí)行，但是在后續(xù)的代碼里，是沒有去申請信號量的，而是直接就Swait成功了，這樣在執(zhí)行Ssignal時就會導(dǎo)致信號量憑空的增加了，也就無法正確的表征系統(tǒng)中的資源數(shù)量了。

2.一個簡單的示例

​ 下面我們就對代碼進行優(yōu)化，大家可以回顧一下AND型信號量，當其因為資源不足時，需要將線程插入到第一個無法滿足條件(即Si<1)的信號量對應(yīng)的等待隊列中，并且將程序計數(shù)器放置到Swait操作的開始處，所以我們對Swait代碼進行修改如下：

  1. public static void Swait(String id, Semaphore s1, Semaphore s2) throws InterruptedException { 
  2.  
  3. lock.tryLock(1, TimeUnit.SECONDS); 
  4.  
  5. log.info("當前的兩個信號量的狀態(tài)：【{},{}】", s1.availablePermits(), s2.availablePermits()); 
  6.  
  7. //如果申請不到，就掛起線程，并將線程插入到condition的隊列中 
  8.  
  9. while (s1.availablePermits() < 1 || s2.availablePermits() < 1) { 
  10.  
  11. if (s1.availablePermits() < 1) { 
  12.  
  13. log.info("線程【{}】被掛起到信號量【{}】中", id, s1); 
  14.  
  15. condition1.await(); 
  16.  
  17. } else { 
  18.  
  19. log.info("線程【{}】被掛起到信號量【{}】中", id, s2); 
  20.  
  21. condition2.await(); 
  22.  
  23. } 
  24.  
  25. log.info("被掛起的線程【{}】被喚醒執(zhí)行。", id); 
  26.  
  27. } 
  28.  
  29. log.info("為線程【{}】分配資源！", id); 
  30.  
  31. s1.acquire(); 
  32.  
  33. s2.acquire(); 
  34.  
  35. lock.unlock(); 
  36.  
  37. } 

​ 在上面的代碼中，我們將請求的資源放到一個循環(huán)條件中，以滿足將程序計數(shù)器放置到Swait操作的開始處，在每次被喚醒后都要重新判斷資源是否足夠，如果足夠才跳出循環(huán)，否則就再次自我阻塞。

3.一個可以同時申請N個的Swait操作

​ 如果你知道了信號量的種類數(shù)(系統(tǒng)中的資源類型)，其實上面的代碼已經(jīng)可以滿足一定的需要了，只需要我們將所有的信號量寫入到參數(shù)列表中即可。但是對于致力于代碼的復(fù)用，這里就有些差強人意了，因此我們再次對代碼進行改進，代碼如下所示：

  1. public static void Swait(String id, Semaphore... list) throws InterruptedException { 
  2.  
  3. lock.lock(); 
  4.  
  5. //如果資源不足，就掛起線程，并將線程插入到condition的隊列中 
  6.  
  7. while (true) { 
  8.  
  9. int count=0; 
  10.  
  11. //循環(huán)判斷參數(shù)列表中信號量的可用值 
  12.  
  13. for (Semaphore semaphore:list){ 
  14.  
  15. if(semaphore.availablePermits()>0){ 
  16.  
  17. count++; 
  18.  
  19. } 
  20.  
  21. } 
  22.  
  23. //如果資源都滿足，則跳出循環(huán)，進行資源分配 
  24.  
  25. if(count == list.length){ 
  26.  
  27. break; 
  28.  
  29. } 
  30.  
  31. log.info("線程【{}】被掛起-----", id); 
  32.  
  33. //將當前線程阻塞 
  34.  
  35. condition1.await(); 
  36.  
  37. log.info("被掛起的線程【{}】被喚醒執(zhí)行。", id); 
  38.  
  39. } 
  40.  
  41. log.info("為線程【{}】分配資源！", id); 
  42.  
  43. //分配資源 
  44.  
  45. for (Semaphore semaphore:list){ 
  46.  
  47. semaphore.acquire(); 
  48.  
  49. } 
  50.  
  51. lock.unlock(); 
  52.  
  53. } 
  54.  
  55. public static void Ssignal(String id, Semaphore... list) throws InterruptedException { 
  56.  
  57. log.info("線程【{}】執(zhí)行了釋放資源", id); 
  58.  
  59. lock.tryLock(1, TimeUnit.SECONDS); 
  60.  
  61. //循環(huán)釋放信號量 
  62.  
  63. for (Semaphore semaphore:list){ 
  64.  
  65. semaphore.release(); 
  66.  
  67. } 
  68.  
  69. //喚醒等待隊列中的線程 
  70.  
  71. condition.signal(); 
  72.  
  73. lock.unlock(); 
  74.  
  75. } 

​ 為此，我們將方法中的信號量列表改為可變的參數(shù)列表，這樣在傳參的時候就可以方便的進行了，但是也會存才一些問題，比如無法約束“借出”與“歸還”的信號量的數(shù)量是否一致。并且因為信號量的數(shù)量不定，所以無法為每個信號量新建一個條件變量(Condition)，因此在上面的代碼中所有的信號量公用一個條件變量，所有阻塞的線程都插入在其阻塞隊列中。

4.一個完整的例子

​ 這里我們使用一個經(jīng)典的進程同步問題來演示我們使用Java模擬的AND型信號量，在這里，我們采用生產(chǎn)者–消費者問題來演示，完整的代碼如下：

  1. //用來保證互斥的訪問臨界區(qū)(緩存區(qū)) 
  2.  
  3. static final Semaphore mutex = new Semaphore(1); 
  4.  
  5. //緩沖區(qū)，最大容量為50 
  6.  
  7. static List<Integer> buffer = new ArrayList<>(); 
  8.  
  9. //緩沖區(qū)中還可放入的消息數(shù)量 
  10.  
  11. static final Semaphore empty = new Semaphore(50); 
  12.  
  13. //緩沖區(qū)中的消息數(shù)量 
  14.  
  15. static final Semaphore full = new Semaphore(0); 
  16.  
  17. //可重入鎖和條件變量 
  18.  
  19. static Lock lock = new ReentrantLock(); 
  20.  
  21. static Condition condition = lock.newCondition(); 
  22.  
  23. //用與輔助的簡單的生成消息 
  24.  
  25. static Integer count = 0; 
  26.  
  27. //生產(chǎn)者 
  28.  
  29. static class Producer extends Thread { 
  30.  
  31. Producer(String name) { 
  32.  
  33. super.setName(name); 
  34.  
  35. } 
  36.  
  37. @Override 
  38.  
  39. public void run() { 
  40.  
  41. do { 
  42.  
  43. try { 
  44.  
  45. Swait(this.getName(), mutex, empty); 
  46.  
  47. log.info("生產(chǎn)了一條消息：【{}】", count); 
  48.  
  49. buffer.add(count++); 
  50.  
  51. Thread.sleep(1000); 
  52.  
  53. Ssignal(this.getName(), mutex, full); 
  54.  
  55. } catch (InterruptedException e) { 
  56.  
  57. log.error("生產(chǎn)消息時產(chǎn)生異常！"); 
  58.  
  59. } 
  60.  
  61. } while (true); 
  62.  
  63. } 
  64.  
  65. } 
  66.  
  67. //消費者 
  68.  
  69. static class Consumer extends Thread { 
  70.  
  71. Consumer(String name) { 
  72.  
  73. super.setName(name); 
  74.  
  75. } 
  76.  
  77. @Override 
  78.  
  79. public void run() { 
  80.  
  81. do { 
  82.  
  83. try { 
  84.  
  85. Swait(this.getName(), mutex, full); 
  86.  
  87. log.info("消費了一條消息：【{}】", buffer.remove(0)); 
  88.  
  89. Thread.sleep(1000); 
  90.  
  91. Ssignal(this.getName(), mutex, empty); 
  92.  
  93. } catch (InterruptedException e) { 
  94.  
  95. log.error("消費消息時產(chǎn)生異常！"); 
  96.  
  97. } 
  98.  
  99. } while (true); 
  100.  
  101. } 
  102.  
  103. } 
  104.  
  105. public static void Swait(String id, Semaphore... list) throws InterruptedException { 
  106.  
  107. lock.lock(); 
  108.  
  109. //如果資源不足，就掛起線程，并將線程插入到condition的隊列中 
  110.  
  111. while (true) { 
  112.  
  113. int count=0; 
  114.  
  115. for (Semaphore semaphore:list){ 
  116.  
  117. if(semaphore.availablePermits()>0){ 
  118.  
  119. count++; 
  120.  
  121. } 
  122.  
  123. } 
  124.  
  125. if(count == list.length){ 
  126.  
  127. break; 
  128.  
  129. } 
  130.  
  131. log.info("線程【{}】被掛起", id); 
  132.  
  133. condition.await(); 
  134.  
  135. log.info("被掛起的線程【{}】被喚醒執(zhí)行。", id); 
  136.  
  137. } 
  138.  
  139. log.info("為線程【{}】分配資源！", id); 
  140.  
  141. for (Semaphore semaphore:list){ 
  142.  
  143. semaphore.acquire(); 
  144.  
  145. } 
  146.  
  147. lock.unlock(); 
  148.  
  149. } 
  150.  
  151. public static void Ssignal(String id, Semaphore... list) throws InterruptedException { 
  152.  
  153. log.info("線程【{}】執(zhí)行了釋放資源", id); 
  154.  
  155. lock.tryLock(1, TimeUnit.SECONDS); 
  156.  
  157. for (Semaphore semaphore:list){ 
  158.  
  159. semaphore.release(); 
  160.  
  161. } 
  162.  
  163. //喚醒等待隊列中的一個線程 
  164.  
  165. condition.signal(); 
  166.  
  167. lock.unlock(); 
  168.  
  169. } 
  170.  
  171. public static void main(String[] args) { 
  172.  
  173. Producer p1 = new Producer("p1"); 
  174.  
  175. Consumer c1 = new Consumer("c1"); 
  176.  
  177. p1.start(); 
  178.  
  179. c1.start(); 
  180.  
  181. } 

​ 上面代碼都是可以直接執(zhí)行的，如果不需要使用參數(shù)列表，可以將上面的Swait方法進行替換即可(記得創(chuàng)建對應(yīng)的條件變量)。

​ 下圖是部分的執(zhí)行結(jié)果： 

程序員：Java并發(fā)編程（JUC）模擬AND型信號量

又到了分隔線以下，本文到此就結(jié)束了，本文內(nèi)容全部都是由博主自己進行整理并結(jié)合自身的理解并且進行的代碼編寫，如果有什么錯誤，還請批評指正。

​ 本文的所有java代碼都已通過測試，對其中有什么疑惑的，可以評論區(qū)留言，歡迎你的留言與討論;另外原創(chuàng)不易，如果本文對你有所幫助，還請留下個贊，以表支持。

​ 希望本文可以幫助你理解加深理解進程同步，也可以幫助你理解Java并發(fā)編程.

 

責(zé)任編輯：武曉燕 來源： Csdn博客
JavaAND信號量
相關(guān)推薦

2016-11-23 16:08:24

Python處理器分布式系統(tǒng)

2024-04-10 08:16:20

多線程編程Java并發(fā)編程

2020-09-25 07:34:40

Linux系統(tǒng)編程信號量

2009-12-08 12:14:43

2021-04-13 09:20:15

鴻蒙HarmonyOS應(yīng)用開發(fā)

2010-04-21 16:50:31

Unix信號量

2020-11-05 09:59:24

Linux內(nèi)核信號量

2010-04-21 16:25:13

Unix信號量

2010-04-21 16:42:48

Unix信號量

2021-09-07 07:53:42

Semaphore 信號量源碼

2010-03-17 16:36:10

Java信號量模型

2010-04-21 15:37:38

Unix信號量

2024-07-25 11:53:53

2010-03-16 17:52:27

Java多線程信號量

2024-10-29 15:23:45

Python線程安全

2010-07-15 15:32:10

Perl線程

2010-04-21 17:10:25

Unix信號量

2017-05-11 14:05:25

Consul分布式信號量

2021-02-03 20:10:29

Linux信號量shell

2020-11-10 15:25:26

SemaphoreLinux翻譯
點贊
收藏

51CTO技術(shù)棧公眾號