1. 云图网首页
  2. 业界资讯

java中的信号量semaphore实现生产者消费者模式详解编程语言

• 业界资讯

Semaphore 信号量，就是一个允许实现设置好的令牌。也许有1个，也许有10个或更多。 
谁拿到令牌(acquire)就可以去执行了，如果没有令牌则需要等待。 
执行完毕，一定要归还(release)令牌，否则令牌会被很快用光，别的线程就无法获得令牌而执行下去了。

 

请仔细体会里面关于仓库的处理，

1 是如何保证入库时，如果仓库满就等待，

2 出库时，如果仓库无货就等待的。

3 以及对仓库只有10个库位的处理。

4 对同步问题的处理。

 

 

[java] 
view plain
copy

  1. import java.util.concurrent.Semaphore;  
  2. /** 
  3.  * 老紫竹JAVA提高教程-信号量(Semaphore)的使用。<br> 
  4.  * 生产者和消费者的例子，库存的管理。 
  5.  *  
  6.  * @author 老紫竹(java2000.net,laozizhu.com) 
  7.  */  
  8. public class TestSemaphore {  
  9.   public static void main(String[] args) {  
  10.     // 启动线程  
  11.     for (int i = 0; i <= 3; i++) {  
  12.       // 生产者  
  13.       new Thread(new Producer()).start();  
  14.       // 消费者  
  15.       new Thread(new Consumer()).start();  
  16.     }  
  17.   }  
  18.   // 仓库  
  19.   static Warehouse buffer = new Warehouse();  
  20.   // 生产者，负责增加  
  21.   static class Producer implements Runnable {  
  22.     static int num = 1;  
  23.     @Override  
  24.     public void run() {  
  25.       int n = num++;  
  26.       while (true) {  
  27.         try {  
  28.           buffer.put(n);  
  29.           System.out.println(“>” + n);  
  30.           // 速度较快。休息10毫秒  
  31.           Thread.sleep(10);  
  32.         } catch (InterruptedException e) {  
  33.           e.printStackTrace();  
  34.         }  
  35.       }  
  36.     }  
  37.   }  
  38.   // 消费者，负责减少  
  39.   static class Consumer implements Runnable {  
  40.     @Override  
  41.     public void run() {  
  42.       while (true) {  
  43.         try {  
  44.           System.out.println(“<“ + buffer.take());  
  45.           // 速度较慢，休息1000毫秒  
  46.           Thread.sleep(1000);  
  47.         } catch (InterruptedException e) {  
  48.           e.printStackTrace();  
  49.         }  
  50.       }  
  51.     }  
  52.   }  
  53.   /** 
  54.    * 仓库 
  55.    *  
  56.    * @author 老紫竹(laozizhu.com) 
  57.    */  
  58.   static class Warehouse {  
  59.     // 非满锁  
  60.     final Semaphore notFull = new Semaphore(10);  
  61.     // 非空锁  
  62.     final Semaphore notEmpty = new Semaphore(0);  
  63.     // 核心锁  
  64.     final Semaphore mutex = new Semaphore(1);  
  65.     // 库存容量  
  66.     final Object[] items = new Object[10];  
  67.     int putptr, takeptr, count;  
  68.     /** 
  69.      * 把商品放入仓库.<br> 
  70.      *  
  71.      * @param x 
  72.      * @throws InterruptedException 
  73.      */  
  74.     public void put(Object x) throws InterruptedException {  
  75.       // 保证非满  
  76.       notFull.acquire();  
  77.       // 保证不冲突  
  78.       mutex.acquire();  
  79.       try {  
  80.         // 增加库存  
  81.         items[putptr] = x;  
  82.         if (++putptr == items.length)  
  83.           putptr = 0;  
  84.         ++count;  
  85.       } finally {  
  86.         // 退出核心区  
  87.         mutex.release();  
  88.         // 增加非空信号量，允许获取商品  
  89.         notEmpty.release();  
  90.       }  
  91.     }  
  92.     /** 
  93.      * 从仓库获取商品 
  94.      *  
  95.      * @return 
  96.      * @throws InterruptedException 
  97.      */  
  98.     public Object take() throws InterruptedException {  
  99.       // 保证非空  
  100.       notEmpty.acquire();  
  101.       // 核心区  
  102.       mutex.acquire();  
  103.       try {  
  104.         // 减少库存  
  105.         Object x = items[takeptr];  
  106.         if (++takeptr == items.length)  
  107.           takeptr = 0;  
  108.         –count;  
  109.         return x;  
  110.       } finally {  
  111.         // 退出核心区  
  112.         mutex.release();  
  113.         // 增加非满的信号量，允许加入商品  
  114.         notFull.release();  
  115.       }  
  116.     }  
  117.   }  
  118. }  

转载出处：http://blog.csdn.net/java2000_net/article/details/3997449

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/13750.html

赞 (0)
0
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论