1. package qbb;
   
2. 
   
3. class Resource {
   
4.         private String name;
   
5.         private int no = 1;
   
6.         private boolean flag = false;
   
7.         public synchronized void produce(String name) {
   
8.                 if(flag) {
   
9.                         try {
   
10.                                 wait();
    
11.                         } catch (InterruptedException e) {
    
12.                                 e.printStackTrace();
    
13.                         }
    
14.                 }
    
15.                 this.name = name + "---" + no++;
    
16.                 System.out.println(Thread.currentThread().getName() +
    
17.                                 "---生产者: " + this.name);
    
18.                 flag = true;
    
19.                 notify();
    
20.         }
    
21.         public synchronized void consume() {
    
22.                 if(!flag) {
    
23.                         try {
    
24.                                 wait();
    
25.                         } catch (InterruptedException e) {
    
26.                                 e.printStackTrace();
    
27.                         }
    
28.                 }
    
29.                 System.out.println(Thread.currentThread().getName() +
    
30.                                 "---消费者----: " + name);
    
31.                 flag = false;
    
32.                 notify();
    
33.         }
    
34. }
    
35. class Producer implements Runnable {
    
36.         private Resource r;
    
37.         Producer(Resource r) {
    
38.                 this.r = r;
    
39.         }
    
40.         public void run() {
    
41.                 while(true) {
    
42.                         r.produce("商品");
    
43.                 }
    
44.         }
    
45. }
    
46. class Consumer implements Runnable {
    
47.         private Resource r;
    
48.         Consumer(Resource r) {
    
49.                 this.r = r;
    
50.         }
    
51.         public void run() {
    
52.                 while(true) {
    
53.                         r.consume();
    
54.                 }
    
55.         }
    
56. }
    
57. public class ProducerConsumer {
    
58.         public static void main(String[] args) {
    
59.                 Resource res = new Resource();
    
60.                 Producer pro = new Producer(res);
    
61.                 Consumer con = new Consumer(res);
    
62.                 Thread t1 = new Thread(pro);
    
63.                 Thread t2 = new Thread(pro);
    
64.                 Thread t3 = new Thread(con);
    
65.                 Thread t4 = new Thread(con);
    
66.                 t1.start();
    
67.                 t2.start();
    
68.                 t3.start();
    
69.                 t4.start();
    
70.         }
    
71. }

复制代码

运行结果会出现以下片段：

Thread-2---消费者----: 商品---477219

Thread-3---消费者----: 商品---477219

Thread-2---消费者----: 商品---477219

Thread-3---消费者----: 商品---477219

Thread-2---消费者----: 商品---477219

怎么解释呢？线程间怎么切换才能出现这种结果呢？

线程这个东西是动态的，这个真想画图给你解释，又怕画的不明白，毕向东java基础视频第14天第26个视频有详细介绍{:soso_e112:}可以回顾回顾

黑马李昂 发表于 2013-8-3 23:32
与楼主共同学习

完整代码如下

哥们，谢谢
不过，我知道正确的代码怎么写
我就是想知道再不同步的情况下
四个线程间怎么切换才能出现上面的结果
想把这个过程搞清楚
有点找虐的意思:lol

1. public synchronized void produce(String name) {
   
2. 
   
3. if(flag) {//问题出现在这里：if判断标记，只有一次，会导致不该运行的线程运行了。出现了数据错误的情况。while判断标记，解决了线程获取执行权后，是否要运行！
   
4. 
   
5. try {
   
6. 
   
7. wait();
   
8. 
   
9. } catch (InterruptedException e) {
   
10. 
    
11. e.printStackTrace();
    
12. 
    
13. }
    
14. 
    
15. }
    
16. 
    
17. this.name = name + "---" + no++;
    
18. 
    
19. System.out.println(Thread.currentThread().getName() +
    
20. 
    
21. "---生产者: " + this.name);
    
22. 
    
23. flag = true;
    
24. 
    
25. notify();//同时这里改成notifyAll();不然出现死锁情况
    
26. 
    
27. }
    
28. 
    

复制代码

与楼主共同学习{:soso_e100:}

完整代码如下

1. class Resource
   
2. {
   
3. private String name;
   
4. private int count = 1;
   
5. private boolean flag = false;
   
6. public synchronized void set(String name)
   
7. {
   
8. while(flag)
   
9. try{this.wait();}catch(InterruptedException e){}
   
10. 
    
11. this.name = name + count;
    
12. count++;
    
13. System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
    
14. flag = true;
    
15. notifyAll();
    
16. }
    
17. 
    
18. public synchronized void out()// t3
    
19. {
    
20. while(!flag)
    
21. try{this.wait();}catch(InterruptedException e){}
    
22. System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
    
23. flag = false;
    
24. notifyAll();
    
25. }
    
26. }
    
27. 
    
28. class Producer implements Runnable
    
29. {
    
30. private Resource r;
    
31. Producer(Resource r)
    
32. {
    
33. this.r = r;
    
34. }
    
35. public void run()
    
36. {
    
37. while(true)
    
38. {
    
39. r.set("商品");
    
40. }
    
41. }
    
42. }
    
43. 
    
44. class Consumer implements Runnable
    
45. {
    
46. private Resource r;
    
47. Consumer(Resource r)
    
48. {
    
49. this.r = r;
    
50. }
    
51. public void run()
    
52. {
    
53. while(true)
    
54. {
    
55. r.out();
    
56. }
    
57. }
    
58. }
    
59. 
    
60. 
    
61. 
    
62. class ProducerConsumerDemo
    
63. {
    
64. public static void main(String[] args)
    
65. {
    
66. Resource r = new Resource();
    
67. Producer pro = new Producer(r);
    
68. Consumer con = new Consumer(r);
    
69. 
    
70. Thread t0 = new Thread(pro);
    
71. Thread t1 = new Thread(pro);
    
72. Thread t2 = new Thread(con);
    
73. Thread t3 = new Thread(con);
    
74. t0.start();
    
75. t1.start();
    
76. t2.start();
    
77. t3.start();
    
78. 
    
79. }
    

复制代码