黑马程序员技术交流社区

标题: 关于生产者消费者的问题 [打印本页]
作者: 宋超2356    时间: 2014-3-27 22:19
标题: 关于生产者消费者的问题
过去写过的一个生产者消费者的操作，最近把它写完实现了，发现最早生产的那几个总是最后才被消费~问题在哪呢，不是很明白
还有就是上面如果有三个生产者，运行出来就就是一塌糊涂该怎么改呢
  1. public class Test {
  2.         public static void main(String[] args) {
  3.                 SyncStack ss = new SyncStack();
  4.                 Producer p = new Producer(ss);
  5.                 Consumer c = new Consumer(ss);
  6.                 //new Thread(p).start();    这里面的两句
  7.                 //new Thread(p).start();
  8.                 new Thread(p).start();
  9.                 new Thread(c).start();
  10.         }
  11. }

  13. class Produce {
  14.         int id;
  15.         Produce(int id) {
  16.                 this.id = id;
  17.         }
  18.         public String toString() {
  19.                 return "Produc : " + id;
  20.         }
  21. }

  23. class SyncStack {
  24.         int index = 0;
  25.         Produce[] arr = new Produce[6];
  26.        
  27.         public synchronized void push(Produce pd) {
  28.                 while(index == arr.length) {
  29.                         try {
  30.                                 this.wait();
  31.                         } catch (InterruptedException e) {
  32.                                 e.printStackTrace();
  33.                         }
  34.                 }
  35.                 this.notifyAll();               
  36.                 arr[index] = pd;
  37.                 index ++;
  38.         }
  39.        
  40.         public synchronized Produce pop() {
  41.                 while(index == 0) {
  42.                         try {
  43.                                 this.wait();
  44.                         } catch (InterruptedException e) {
  45.                                 e.printStackTrace();
  46.                         }
  47.                 }
  48.                 this.notifyAll();
  49.                 index--;
  50.                 return arr[index];
  51.         }
  52. }

  54. class Producer implements Runnable {
  55.         SyncStack ss = null;
  56.         Producer(SyncStack ss) {
  57.                 this.ss = ss;
  58.         }
  59.        
  60.         public void run() {
  61.                 for(int i=0; i<20; i++) {
  62.                         Produce pd = new Produce(i);
  63.                         ss.push(pd);
  64. System.out.println("生产了：" + pd);
  65.                         try {
  66.                                 Thread.sleep((int)(Math.random() * 200));
  67.                         } catch (InterruptedException e) {
  68.                                 e.printStackTrace();
  69.                         }                       
  70.                 }
  71.         }
  72. }

  74. class Consumer implements Runnable {
  75.         SyncStack ss = null;
  76.         Consumer(SyncStack ss) {
  77.                 this.ss = ss;
  78.         }
  79.        
  80.         public void run() {
  81.                 for(int i=0; i<20; i++) {
  82.                         Produce pd = ss.pop();
  83. System.out.println("消费了: " + pd);
  84.                         try {
  85.                                 Thread.sleep((int)(Math.random() * 1000));
  86.                         } catch (InterruptedException e) {
  87.                                 e.printStackTrace();
  88.                         }                       
  89.                 }
  90.         }
  91. }
复制代码



作者: 你好！默默    时间: 2014-3-27 22:37
这不是操作系统么？好厉害的样子
作者: 霍振鹏    时间: 2014-3-28 00:05
本帖最后由 霍振鹏 于 2014-3-28 00:07 编辑

我注释的1111111111111的是解决你的第一个问题：先生产的应该先消费
注释22222222222222222的是解决三个生产者问题
  1. package aaaa;
  2. public class Test {
  3.         public static void main(String[] args) {
  4.                 SyncStack ss = new SyncStack();
  5.                 Producer p = new Producer(ss);
  6.                 Consumer c = new Consumer(ss);
  7.                 new Thread(p).start();   // 这里面的两句
  8.                 new Thread(p).start();
  9.                 new Thread(p).start();
  10.                 new Thread(c).start();
  11.         }
  12. }

  14. class Produce {
  15.         int id;
  16.         Produce(int id) {
  17.                 this.id = id;
  18.         }
  19.         public String toString() {
  20.                 return "Produc : " + id;
  21.         }
  22. }

  24. class SyncStack {
  25.         int index = 0;
  26.         int currentputindex=0;///11111111111111111111111111111111111111111111111111111111
  27.         int currentpopindex=0;
  28.         Produce[] arr = new Produce[6];
  29.         
  30.         public synchronized void push(Produce pd) {
  31.                 while(index == arr.length) {//////11111111111111111111111111111111111111111111111111111/
  32.                         try {
  33.                                 this.wait();
  34.                         } catch (InterruptedException e) {
  35.                                 e.printStackTrace();
  36.                         }
  37.                 }
  38.                 this.notifyAll();               
  39.                 arr[(currentputindex++)%arr.length] = pd;//1111111111111111111111111111
  40.                 index ++;
  41.         }
  42.         
  43.         public synchronized Produce pop() {
  44.                 while(index == 0) {
  45.                         try {
  46.                                 this.wait();
  47.                         } catch (InterruptedException e) {
  48.                                 e.printStackTrace();
  49.                         }
  50.                 }
  51.                 this.notifyAll();
  52.                 index--;
  53.                 return arr[(currentpopindex++)%arr.length];///11111111111111111111111111111111111111111111
  54.         }
  55. }

  57. class Producer implements Runnable {
  58.         SyncStack ss = null;
  59.         int i=0;
  60.         Producer(SyncStack ss) {
  61.                 this.ss = ss;
  62.         }
  63.         
  64.         public void run() {
  65.                 for(; i<20; ) {////////22222222222222222222
  66.                        
  67.                         synchronized (ss.getClass()) {////////////////222222222222222222222222222222222222222
  68.                                 if(i<20)
  69.                                 {
  70.                                 Produce pd = new Produce(i);
  71.                                 ss.push(pd);
  72.                                  i++;
  73.                                  System.out.println("生产了：" + pd);
  74.                                 }
  75.                                                 }
  76.                        

  78.                         try {
  79.                                 Thread.sleep((int)(Math.random() * 200));
  80.                         } catch (InterruptedException e) {
  81.                                 e.printStackTrace();
  82.                         }                        
  83.                 }
  84.         }
  85. }

  87. class Consumer implements Runnable {
  88.         SyncStack ss = null;
  89.         Consumer(SyncStack ss) {
  90.                 this.ss = ss;
  91.         }
  92.         
  93.         public void run() {
  94.                 for(int i=0; i<20; i++) {
  95.                         Produce pd = ss.pop();
  96. System.out.println("消费了: " + pd);
  97.                         try {
  98.                                 Thread.sleep((int)(Math.random() * 1000));
  99.                         } catch (InterruptedException e) {
  100.                                 e.printStackTrace();
  101.                         }                        
  102.                 }
  103.         }
  104. }
复制代码

QQ2.png (74.41 KB, 下载次数: 45)

QQ2.png
作者: 宋超2356    时间: 2014-3-28 17:49
霍振鹏 发表于 2014-3-28 00:05
我注释的1111111111111的是解决你的第一个问题：先生产的应该先消费
注释22222222222222222的是解决三个生 ...

真心是大神啊~谢谢啦
作者: 霍振鹏    时间: 2014-3-28 17:53
呵呵 互相学习，，，先别结贴，得个技术分先，，，呵呵
作者: 霍振鹏    时间: 2014-3-28 17:54
宋超2356 发表于 2014-3-28 17:49
真心是大神啊~谢谢啦


呵呵 互相学习，，，先别结贴，得个技术分先，，，呵呵



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