黑马程序员技术交流社区

标题: jdk1.5同步锁模拟经典同步问题之生产者消费者 [打印本页]
作者: 苟苟    时间: 2015-5-4 16:54
标题: jdk1.5同步锁模拟经典同步问题之生产者消费者
jdk1.5同步锁模拟经典同步问题之生产者消费者. 代码如下
  1. import java.util.ArrayList;
  2. import java.util.concurrent.locks.Condition;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;

  6. /**
  7. * 使用JDK1.5线程同步锁新特性实现生产者和消费者的例子
  8. *
  9. */
  10. class Main {
  11.         public static void main(String[] args) {
  12.                 Buffer buffer = new Buffer();
  13.                 Producer producer  = new Producer(buffer);
  14.                 Consumer consumer  = new Consumer(buffer);
  15.                
  16.                 producer.start();
  17.                 consumer.start();
  18.         }
  19. }

  21. // 商品缓冲区
  22. class Buffer {
  23.         private Lock lock;
  24.         private Condition full;
  25.         private Condition empty;

  27.         //商品缓冲区最大容量4
  28.         private static int MAX_CAPACITY = 4;
  29.         private ArrayList<Commodity> buffer = new ArrayList<Commodity>(MAX_CAPACITY);

  31.         Buffer() {
  32.                 lock = new ReentrantLock();
  33.                 full = lock.newCondition();
  34.                 empty = lock.newCondition();
  35.         }

  37.         public void add(String local, float weight) {
  38.                 lock.lock();

  40.                 try {
  41.                         if (buffer.size() >= MAX_CAPACITY) {
  42.                                 System.out.println("buffer满了, 阻塞生产线程");
  43.                                 full.await();
  44.                         }
  45.                        
  46.                         Commodity commodity = new Commodity(local, weight);
  47.                         buffer.add(commodity);
  48.                         System.out.println("生产: " + commodity.toString() + "  " + "还剩下商品   " + buffer.size());
  49.                         empty.signal();
  50.                 } catch (InterruptedException e) {
  51.                         e.printStackTrace();
  52.                 } finally {
  53.                         lock.unlock();
  54.                 }
  55.         }

  57.         public void remove() {
  58.                 lock.lock();

  60.                 try {
  61.                         if (buffer.size() <= 0) {
  62.                                 System.out.println("buffer空了, 阻塞消费者线程       " + buffer.size());
  63.                                 empty.await();
  64.                         }

  66.                         Commodity commodity = buffer.remove(buffer.size() - 1);
  67.                         System.out.println("消费: " + commodity.toString() + "  " + "还剩下商品   " + buffer.size());

  69.                         full.signal();
  70.                 } catch (InterruptedException e) {
  71.                         e.printStackTrace();
  72.                 } finally {
  73.                         lock.unlock();
  74.                 }
  75.         }
  76. }

  78. /**
  79. *
  80. * 生产的商品实体
  81. */
  82. class Commodity {
  83.         private String local;
  84.         private float weight;

  86.         public Commodity(String local, float weight) {
  87.                 this.local = local;
  88.                 this.weight = weight;
  89.         }

  91.         @Override
  92.         public String toString() {
  93.                 return "Commodity [local=" + local + ", weight=" + weight + "]";
  94.         }

  96. }

  98. // 生产者线程
  99. class Producer extends Thread {
  100.         private Buffer buffer;

  102.         Producer(Buffer buffer) {
  103.                 this.buffer = buffer;
  104.         }

  106.         @Override
  107.         public void run() {
  108.                 for (int i = 0;; i++) {
  109.                         try {
  110.                                 Thread.sleep(500);
  111.                         } catch (InterruptedException e) {
  112.                                 e.printStackTrace();
  113.                         }
  114.                        
  115.                        
  116.                         buffer.add("BJ", i);
  117.                 }
  118.         }
  119. }

  121. // 消费者线程
  122. class Consumer extends Thread {

  124.         private Buffer buffer;

  126.         Consumer(Buffer buffer) {
  127.                 this.buffer = buffer;
  128.         }

  130.         @Override
  131.         public void run() {
  132.                 while(true){
  133.                         try {
  134.                                 Thread.sleep(500);
  135.                         } catch (InterruptedException e) {
  136.                                 e.printStackTrace();
  137.                         }
  138.                        
  139.                         buffer.remove();
  140.                 }
  141.         }
  142. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2