1. /*
   
2. 线程模拟生产者与消费者
   
3. 要求：生产一个消费一个
   
4. */
   
5. class ProducterConsumerDemo
   
6. {
   
7. public static void main(String[] args)
   
8. {
   
9. Resource r = new Resource(); //定义商品资源
   
10. Producter pro = new Producter(r);//创建生产者对象
    
11. Consumer son = new Consumer(r); //创建消费者对象
    
12. 
    
13. //创建两个生产者即两个线程
    
14. Thread t1 = new Thread(pro);
    
15. Thread t2 = new Thread(pro);
    
16. 
    
17. //创建两个消费者即两个线程
    
18. Thread t3 = new Thread(son);
    
19. Thread t4 = new Thread(son);
    
20. 
    
21. //启动四个线程并执行相应的run方法
    
22. t1.start();
    
23. t2.start();
    
24. t3.start();
    
25. t4.start();
    
26. 
    
27. 
    
28. }
    
29. }
    
30. /*
    
31. 定义商品类
    
32. */
    
33. class Resource
    
34. {
    
35. private String name; //商品的名字
    
36. private int count =1; //商品的编号
    
37. private boolean flag = false;
    
38. 
    
39. public synchronized void set(String name)
    
40. {
    
41. if(flag)
    
42. try{this.wait();}catch(Exception e){}
    
43. this.name = name + "--" + count++;//
    
44. System.out.println(Thread.currentThread().getName() + "...生产者 " + this.name);
    
45. flag = true;
    
46. this.notify();
    
47. }
    
48. public synchronized void out()
    
49. {
    
50. if(!flag)
    
51. try{this.wait();}catch(Exception e){}
    
52. System.out.println(Thread.currentThread().getName() + "...消费者————" + this.name);
    
53. flag = false;
    
54. this.notify();
    
55. }
    
56. }
    
57. // 商品的生产者
    
58. class Producter implements Runnable
    
59. {
    
60. private Resource res;
    
61. 
    
62. Producter(Resource res)
    
63. {
    
64. this.res = res;
    
65. }
    
66. public void run()
    
67. {
    
68. while(true)
    
69. {
    
70. res.set("商品+");
    
71. }
    
72. }
    
73. }
    
74. //商品的消费者
    
75. class Consumer implements Runnable
    
76. {
    
77. private Resource res;
    
78. 
    
79. Consumer(Resource res)
    
80. {
    
81. this.res = res;
    
82. }
    
83. public void run()
    
84. {
    
85. while(true)
    
86. {
    
87. res.out();
    
88. }
    
89. }
    
90. }

复制代码

我的代码的生产者和消费者不和谐了，有时候生产一个会消费两个或者生产两个消费一个！我弄了半天也没弄懂到底是错在哪里了！请高手指教！！

将if换成while循环  代码中的this.notify(); 改成notifyAll();

1. package demo1;
   
2. 
   
3. /*
   
4. 线程模拟生产者与消费者
   
5. 要求：生产一个消费一个
   
6. */
   
7. class ProducterConsumerDemo {
   
8.         public static void main(String[] args) {
   
9.                 Resource r = new Resource(); // 定义商品资源
   
10.                 Producter pro = new Producter(r);// 创建生产者对象
    
11.                 Consumer son = new Consumer(r); // 创建消费者对象
    
12. 
    
13.                 // 创建两个生产者即两个线程
    
14.                 Thread t1 = new Thread(pro);
    
15.                 Thread t2 = new Thread(pro);
    
16. 
    
17.                 // 创建两个消费者即两个线程
    
18.                 Thread t3 = new Thread(son);
    
19.                 Thread t4 = new Thread(son);
    
20. 
    
21.                 // 启动四个线程并执行相应的run方法
    
22.                 t1.start();
    
23.                 t2.start();
    
24.                 t3.start();
    
25.                 t4.start();
    
26. 
    
27.         }
    
28. }
    
29. 
    
30. /*
    
31. * 定义商品类
    
32. */
    
33. class Resource {
    
34.         private String name; // 商品的名字
    
35.         private int count = 1; // 商品的编号
    
36.         private boolean flag = false;
    
37. 
    
38.         public synchronized void set(String name) {
    
39.                 while (flag)
    
40.                         try {
    
41.                                 this.wait();
    
42.                         } catch (Exception e) {
    
43.                         }
    
44.                 this.name = name + "--" + count++;//
    
45.                 System.out.println(Thread.currentThread().getName() + "...生产者 "
    
46.                                 + this.name);
    
47.                 flag = true;
    
48.                 this.notifyAll();
    
49.         }
    
50. 
    
51.         public synchronized void out() {
    
52.                 while (!flag)
    
53.                         try {
    
54.                                 this.wait();
    
55.                         } catch (Exception e) {
    
56.                         }
    
57.                 System.out.println(Thread.currentThread().getName() + "...消费者————"
    
58.                                 + this.name);
    
59.                 flag = false;
    
60.                 this.notifyAll();
    
61.         }
    
62. }
    
63. 
    
64. // 商品的生产者
    
65. class Producter implements Runnable {
    
66.         private Resource res;
    
67. 
    
68.         Producter(Resource res) {
    
69.                 this.res = res;
    
70.         }
    
71. 
    
72.         public void run() {
    
73.                 while (true) {
    
74.                         res.set("商品+");
    
75.                 }
    
76.         }
    
77. }
    
78. 
    
79. // 商品的消费者
    
80. class Consumer implements Runnable {
    
81.         private Resource res;
    
82. 
    
83.         Consumer(Resource res) {
    
84.                 this.res = res;
    
85.         }
    
86. 
    
87.         public void run() {
    
88.                 while (true) {
    
89.                         res.out();
    
90.                 }
    
91.         }
    
92. }
    

复制代码

我把你的代码改了一下，运行正常，你的错误主要有两个，
第一：判断是用while,而不是if,因为多个线程可能在if的下面，当线程醒来时，根本就有再进行判断，而此时由于一个线程的消费而使务件不成立了，但是由于线程都在if下面，所以根本不需要再次判断就直接再次消费而引起的。
第二：你必须唤醒全部的线程，要不然因为线程的唤醒是随机的，不确定的，当消费了之的，再次唤醒的双是在等待当中的消费线程时，就出出了多消费的情况。如果你使用了多次循还判断，那么必须唤醒的全部线程，然不然可能出现死锁的情况。因为有可能全部的线程都处于等待唤醒的状态。

类似需要有加锁的操作。我也记得不是很清楚，但是毕老师在多线程视频中好像讲的很清楚，建议你看一下！！好像是用等待唤醒机制！

嗯！谢谢各位！问题解决了！