过去写过的一个生产者消费者的操作，最近把它写完实现了，发现最早生产的那几个总是最后才被消费~问题在哪呢，不是很明白
还有就是上面如果有三个生产者，运行出来就就是一塌糊涂该怎么改呢

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. }
    
12. 
    
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. }
    
22. 
    
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. }
    
53. 
    
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. }
    
73. 
    
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. }

复制代码

这不是操作系统么？好厉害的样子

我注释的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. }
    
13. 
    
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. }
    
23. 
    
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. }
    
56. 
    
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.                        
    
77. 
    
78.                         try {
    
79.                                 Thread.sleep((int)(Math.random() * 200));
    
80.                         } catch (InterruptedException e) {
    
81.                                 e.printStackTrace();
    
82.                         }                        
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
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. }

复制代码

霍振鹏 发表于 2014-3-28 00:05
我注释的1111111111111的是解决你的第一个问题：先生产的应该先消费
注释22222222222222222的是解决三个生 ...

真心是大神啊~谢谢啦

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

宋超2356 发表于 2014-3-28 17:49
真心是大神啊~谢谢啦

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