黑马程序员技术交流社区

标题: 生产者与消费者问题 [打印本页]
作者: itheima_llt    时间: 2015-4-11 22:37
标题: 生产者与消费者问题
生产者消费者问题

一、先处理只有1个生产者和1个消费者的情况

二、再处理2个生产者和2个消费者的情况

对于一、
步骤：
1 建立一个资源类，包含成员变量（商品名称，商品编号、监视器）
和方法（设置商品名称和商品编号）

2 建立生产者类，实现Runnable接口，覆盖run方法

3 建立消费者类，实现Runnable接口，覆盖run方法
  1. //1个消费者线程和1个生产者线程
  2. class Resource
  3. {
  4.         private String name;//商品名称
  5.         private int count=1;//商品编号
  6.         private boolean flag = false;//监视器
  7.        
  8.         //设置商品名称，编号自动加1
  9.         public synchronized void set(String name)
  10.         {
  11.                 if(flag)//如果资源监视器为真，那么调用本方法的对象等待
  12.                         try
  13.                         {
  14.                                 this.wait();
  15.                         }
  16.                         catch (Exception e)
  17.                         {
  18.                         }
  19.                                 this.name = name;
  20.                                  count++;
  21.                                  System.out.println(Thread.currentThread().getName()+"..."+name+"...生产者...编号:"+count);
  22.                                 flag = true;
  23.                                 this.notify();//唤醒线程池中的第一个线程
  24.         }

  26.         //获取商品名称和编号
  27.         public synchronized void get()
  28.         {
  29.                 if(!flag)//如果资源监视器为假，那么调用本方法的对象等待
  30.                 try
  31.                 {
  32.                         this.wait();
  33.                 }
  34.                 catch (Exception e)
  35.                 {
  36.                 }
  37.                         System.out.println(Thread.currentThread().getName()+"..."+name+"....消费者.........编号："+count);
  38.                         flag = false;
  39.                         this.notify();//唤醒线程池中的第一线程
  40.         }

  42. }

  44. class Producer implements Runnable
  45. {
  46.         private Resource r;

  48.         //利用传递引用类型变量和构造函数避免造成初始化对象不唯一
  49.         Producer(Resource r)
  50.         {
  51.                 this.r =r;
  52.         }
  53.        
  54.         public void run()
  55.         {
  56.                 while(true)
  57.                         r.set("商品");
  58.         }

  60. }

  62. class Consumer implements Runnable
  63. {
  64.         private Resource r;

  66.         Consumer(Resource r)
  67.         {
  68.                 this.r = r;
  69.         }

  71.         public void run()
  72.         {
  73.                 while(true)
  74.                         r.get();
  75.         }
  76. }






  83. class MyProducerConsumerDemo
  84. {
  85.         public static void main(String[] args)
  86.         {
  87.                 //建立资源对象
  88.                 Resource r =new Resource();
  89.                
  90.                 //建立生产者对象
  91.                 Producer p =new Producer(r);

  93.                 //建立消费者对象
  94.                 Consumer c = new Consumer(r);

  96.                 //建立生产者线程
  97.                 Thread tp1 = new Thread(p);
  98.                
  99.                 //建立消费者线程
  100.                 Thread cp1 = new Thread(c);

  102.                 //启动生产者线程
  103.                 tp1.start();

  105.                 //启动消费者线程
  106.                 cp1.start();
  107.                
  108.                
  109.                 //简化代码
  110.                 //new Thread(new Producer(r)).start();
  111.                 //new Thread(new Consumer(r)).start();
  112.                
  113.         }
  114. }
复制代码
  1. //两个生产者和两个消费者线程
  2. class Resource
  3. {
  4.         private String name;//商品名称
  5.         private int count=1;//商品编号
  6.         private boolean flag = false;//监视器
  7.        
  8.         //设置商品名称，编号自动加1
  9.         public synchronized void set(String name)
  10.         {
  11.                 //if(flag)//如果资源监视器为真，那么调用本方法的对象等待
  12.                 while(flag)
  13.                         try
  14.                         {
  15.                                 this.wait();
  16.                         }
  17.                         catch (Exception e)
  18.                         {
  19.                         }
  20.                                 this.name = name;
  21.                                  count++;
  22.                                  System.out.println(Thread.currentThread().getName()+"..."+name+"...生产者...编号:"+count);
  23.                                 flag = true;
  24.                                 this.notifyAll();//唤醒线程池中的第一个线程
  25.         }

  27.         //获取商品名称和编号
  28.         public synchronized void get()
  29.         {
  30.                
  31.                 //if(!flag)//如果资源监视器为假，那么调用本方法的对象等待
  32.                 while(!flag)
  33.                 try
  34.                 {
  35.                         this.wait();
  36.                 }
  37.                 catch (Exception e)
  38.                 {
  39.                 }
  40.                         System.out.println(Thread.currentThread().getName()+"..."+name+"....消费者.........编号："+count);
  41.                         flag = false;
  42.                         this.notifyAll();//唤醒线程池中的第一线程
  43.         }

  45. }

  47. class Producer implements Runnable
  48. {
  49.         private Resource r;

  51.         //利用传递引用类型变量和构造函数避免造成初始化对象不唯一
  52.         Producer(Resource r)
  53.         {
  54.                 this.r =r;
  55.         }
  56.        
  57.         public void run()
  58.         {
  59.                 while(true)
  60.                         r.set("商品");
  61.         }

  63. }

  65. class Consumer implements Runnable
  66. {
  67.         private Resource r;

  69.         Consumer(Resource r)
  70.         {
  71.                 this.r = r;
  72.         }

  74.         public void run()
  75.         {
  76.                 while(true)
  77.                         r.get();
  78.         }
  79. }






  86. class MyProducerConsumerDemo
  87. {
  88.         public static void main(String[] args)
  89.         {
  90.                 //建立资源对象
  91.                 Resource r =new Resource();

  93.                 //建立生产者对象
  94.                 Producer p =new Producer(r);

  96.                 //建立消费者对象
  97.                 Consumer c = new Consumer(r);

  99.                 //建立生产者线程
  100.                 Thread tp1 = new Thread(p);
  101.                 Thread tp2 = new Thread(p);
  102.                
  103.                 //建立消费者线程
  104.                 Thread cp1 = new Thread(c);
  105.                 Thread cp2 = new Thread(c);

  107.                 //启动生产者线程
  108.                 tp1.start();
  109.                 tp2.start();

  111.                 //启动消费者线程
  112.                 cp1.start();
  113.                 cp2.start();
  114.         }
  115. }
复制代码

运行结果出现：
生产一次，消费2次的情况。
Thread-1...商品...生产者...编号:359
Thread-3...商品....消费者.........编号：359
Thread-2...商品....消费者.........编号：359

生产2次，消费1次的情况。
Thread-1...商品...生产者...编号:3424
Thread-0...商品...生产者...编号:3425
Thread-3...商品....消费者.........编号：3425


这说明，原来在1个生产者和1个消费者安全
但在2个生产者和2个消费者就不安全了。

为什么会这样呢？？
因为在用if语句判断的时候，当线程被唤醒后，它并没有再判断flag,
而是直接执行下一条语句，所以我们可以把if改成while。
> if(flag)//如果资源监视器为真，那么调用本方法的对象等待

改成while(flag)的时候，运行结果为：
Thread-0...商品...生产者...编号:2
Thread-3...商品....消费者.........编号：2
Thread-1...商品...生产者...编号:3
Thread-3...商品....消费者.........编号：3
Thread-0...商品...生产者...编号:4

4个线程全部处于睡眠状态，不再打印。

这又是因为睡眠呢？？
原因是notify唤醒的都是线程池中的第一个线程，
这就导致了被唤醒的线程不一定是对方的线程。
而当唤醒的是本方线程时候，线程就全部陷入了等待。
该怎么解决呢？？
可以用notifyAll();

运行结果显示安全问题被解决！

小结：
在多个生产者和多个消费者的情况下，

用while+notifyAll();

作者: itheima_llt    时间: 2015-4-12 21:52
{:3_54:}自己顶一下！



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