黑马程序员技术交流社区

标题: 生产者消费者问题加锁实现 [打印本页]
作者: 耿渊博    时间: 2014-3-25 22:31
标题: 生产者消费者问题加锁实现
本帖最后由 耿渊博 于 2014-3-25 23:17 编辑

下面代码可以实现带锁的生产者消费者问题吗？
  1. package com.Thread;

  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;




  10. public class ProducerConsumerDemo {

  12.         public static void main(String[] args) {
  13.                 // TODO Auto-generated method stub
  14.                
  15.                 Resource r = new Resource();
  16.                 Producer pro = new Producer(r);
  17.                 Consume con = new Consume(r);
  18.                
  19.                 Thread t1 = new Thread(pro);
  20.                 Thread t2 = new Thread(pro);
  21.                 Thread t3 = new Thread(con);
  22.                 Thread t4 = new Thread(con);
  23.                
  24.                 t1.start();
  25.                 t2.start();
  26.                 t3.start();
  27.                 t4.start();
  28.         }

  30. }
  31. class Resource{
  32.         private String name;
  33.         private int count = 1;
  34.         private boolean flag = false;
  35.         private Lock lock = new ReentrantLock();
  36.         private Condition condition = lock.newCondition();
  37.         
  38.         public  void set(String name)throws InterruptedException{
  39.                 lock.lock();
  40.                 try{
  41.                         while(flag)
  42.                                 condition.await();
  43.                         this.name = name+"--"+count++;
  44.                         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
  45.                         flag = true;
  46.                         condition.signalAll();
  47.                 }
  48.                 finally{
  49.                 lock.unlock();
  50.                 }
  51.         }
  52.         
  53.         public  void out()throws InterruptedException{
  54.                 lock.lock();
  55.                 try{
  56.                         while(!flag)
  57.                                 condition.await();
  58.                         System.out.println(Thread.currentThread().getName()+"...消费者.............."+this.name);
  59.                         flag = false;
  60.                         condition.signalAll();
  61.                 }finally{
  62.                         lock.unlock();
  63.                 }
  64.         }
  65.         
  66. }

  68. class Producer implements Runnable{
  69. private Resource res;

  71. Producer(Resource res){
  72.         this.res = res;
  73. }
  74. public void run(){
  75.         while(true){
  76.                 try {
  77.                         res.set("+商品+");
  78.                 } catch (InterruptedException e) {
  79.                         // TODO Auto-generated catch block
  80.                         e.printStackTrace();
  81.                 }
  82.         }
  83. }
  84. }

  86. class Consume implements Runnable{
  87. private Resource res;

  89. Consume(Resource res){
  90.         this.res = res;
  91. }
  92. public void run(){
  93.         while(true)
  94.                 try {
  95.                         res.out();
  96.                 } catch (InterruptedException e) {
  97.                         // TODO Auto-generated catch block
  98.                         e.printStackTrace();
  99.                 }
  100. }
  101. }
复制代码


作者: papercup    时间: 2014-3-25 22:46
你写的这个不太好，唤醒进程时需要分开唤醒。即定义两个condition 变量。我给你改了一下
  1. package com.Thread;

  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;




  10. public class ProducerConsumerDemo {

  12.         public static void main(String[] args) {
  13.                 // TODO Auto-generated method stub
  14.                
  15.                 Resource r = new Resource();
  16.                 Producer pro = new Producer(r);
  17.                 Consume con = new Consume(r);
  18.                
  19.                 Thread t1 = new Thread(pro);
  20.                 Thread t2 = new Thread(pro);
  21.                 Thread t3 = new Thread(con);
  22.                 Thread t4 = new Thread(con);
  23.                
  24.                 t1.start();
  25.                 t2.start();
  26.                 t3.start();
  27.                 t4.start();
  28.         }

  30. }
  31. class Resource{
  32.         private String name;
  33.         private int count = 1;
  34.         private boolean flag = false;
  35.         private Lock lock = new ReentrantLock();
  36.         private Condition condition_pro = lock.newCondition();//消费者
  37.         private Condition condition_con = lock.newCondition();//生产者
  38.        
  39.         public  void set(String name)throws InterruptedException{
  40.                 lock.lock();
  41.                 try{
  42.                         while(flag)
  43.                                 condition_pro.await();//生产者等待
  44.                         this.name = name+"--"+count++;
  45.                         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
  46.                         flag = true;
  47.                         condition_con.signal();//唤醒消费者
  48.                 }
  49.                 finally{
  50.                 lock.unlock();
  51.                 }
  52.         }
  53.        
  54.         public  void out()throws InterruptedException{
  55.                 lock.lock();
  56.                 try{
  57.                         while(!flag)
  58.                                 condition_con.await();//消费者等待
  59.                         System.out.println(Thread.currentThread().getName()+"...消费者.............."+this.name);
  60.                         flag = false;
  61.                         condition_pro.signal();//唤醒生产者
  62.                 }finally{
  63.                         lock.unlock();
  64.                 }
  65.         }
  66.        
  67. }

  69. class Producer implements Runnable{
  70. private Resource res;

  72. Producer(Resource res){
  73.         this.res = res;
  74. }
  75. public void run(){
  76.         while(true){
  77.                 try {
  78.                         res.set("+商品+");
  79.                 } catch (InterruptedException e) {
  80.                         // TODO Auto-generated catch block
  81.                         e.printStackTrace();
  82.                 }
  83.         }
  84. }
  85. }

  87. class Consume implements Runnable{
  88. private Resource res;

  90. Consume(Resource res){
  91.         this.res = res;
  92. }
  93. public void run(){
  94.         while(true)
  95.                 try {
  96.                         res.out();
  97.                 } catch (InterruptedException e) {
  98.                         // TODO Auto-generated catch block
  99.                         e.printStackTrace();
  100.                 }
  101. }
  102. }
复制代码
作者: 耿渊博    时间: 2014-3-25 23:16
papercup 发表于 2014-3-25 22:46
你写的这个不太好，唤醒进程时需要分开唤醒。即定义两个condition 变量。我给你改了一下 ...

明白了  



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