首先是问题代码

1. package 多线程;
   
2. 
   
3. class 生产者消费者 {
   
4.         public static void main(String[] args) {
   
5.                 Res r = new Res();
   
6.                 boolean flag = false;
   
7.                 Producer p = new Producer(r);
   
8.                 Consumer c = new Consumer(r);
   
9.                 Thread t = new Thread(p);
   
10.                 Thread t2 = new Thread(c);
    
11.                
    
12.                 t.start();
    
13.                 t2.start();
    
14.         }
    
15. }
    
16. class Res{
    
17.         boolean flag = false;
    
18.         int count = 0;
    
19.         public synchronized void setResource(){
    
20.                 count++;
    
21.                 System.out.println(Thread.currentThread().getName()+"生产者------"+count);
    
22.         }
    
23.         public synchronized void getResource(){
    
24.                 System.out.println(Thread.currentThread().getName()+"消费者。。。。。。。。。。。。"+count);
    
25.         }
    
26. }
    
27. class Producer implements Runnable{
    
28.         Res r;
    
29.         
    
30.         Producer(Res r ){
    
31.                 this.r = r;
    
32. 
    
33.         }
    
34.         public void run(){
    
35.                 while(true){
    
36.                         if(!(r.flag)){
    
37.                                 r.setResource();
    
38.                                 r.flag =true;
    
39.                         }
    
40.         
    
41.                 }
    
42.         }
    
43. }
    
44. class Consumer implements Runnable{
    
45.         Res r;
    
46.         Consumer(Res r){
    
47.                 this.r = r;
    
48. 
    
49.         }
    
50.         public void run(){
    
51.                 while(true){
    
52.                         if(r.flag){
    
53.                                 r.getResource();
    
54.                                 r.flag =false;
    
55.                         }
    
56.                 }
    
57. 
    
58.         }
    
59. }

复制代码

接下来是我调试的过程

1. package day3;
   
2. 
   
3. public class Test5 {
   
4.         public static void main(String[] args) {
   
5.                 Res r = new Res();
   
6.                 // boolean flag = false;
   
7.                 Producer p = new Producer(r);
   
8.                 Consumer c = new Consumer(r);
   
9.                 Thread t = new Thread(p);
   
10.                 Thread t2 = new Thread(c);
    
11. 
    
12.                 t.start();
    
13. 
    
14.                 t2.start();
    
15.         }
    
16. }
    
17. 
    
18. class Res {
    
19.         boolean flag = false;
    
20.         int count = 0;
    
21. 
    
22.         public synchronized void setResource() {
    
23.                 count++;
    
24.                 System.out.println(Thread.currentThread().getName() + "生产者------"
    
25.                                 + count);
    
26.         }
    
27. 
    
28.         public synchronized void getResource() {
    
29.                 System.out.println(Thread.currentThread().getName() + "消费者。。。。。。。。。。。。"
    
30.                                 + count);
    
31.         }
    
32. }
    
33. 
    
34. class Producer implements Runnable {
    
35.         Res r;
    
36. 
    
37.         Producer(Res r) {
    
38.                 this.r = r;
    
39.         }
    
40. 
    
41.         public void run() {//因为这里是死循环，只要进来就跳不出去，有可能会出现两个线程交替执行一段时间，但是当flag为true时，这里就死循环了，那cpu不是交替执行线程的吗？难道消费者的线程就一直抢不到执行权吗？就用打印方法验证一下就知道了,发现当加入打印的方法后两个线程还是会有非常小的几率交替执行，当然99.9%的还是死循环的打印方法，所以在两个线程的run方法中加点睡眠时间看看效果,此时将打印的方法都关闭，这时发现生产者生产2商品后程序又死循环了，可以想到这么一种情况，当消费完1号后生产者可以说是瞬间生产2后进入睡眠，之后消费者和生产者可以说是同时醒来，因为生产者是死循环，效率比较快，一直抢得到执行权。为什么这么说，通过打印的方法就可以看到，满屏的pro...out。那也有可能是消费者那里死循环的吧，满屏的cus...out也是可能的？那么把其他的打印语句关掉这里只打开cus...out，又一种神奇的现象出现了，竟然可以看到比较和谐的景象，这又是为什么呢？至此打住！到目前为止答案已经很清晰了，问题就出现在while循环上，那么这里就考虑毕老师视频讲的例子一样，操作资源和标记的事情都交给资源类res去完成，另外在方法中加入wait方法和notify方法实现线程安全和生产消费和谐的画面
    
42.                 if (!(r.flag)) {//总结：错误的代码何其多，我们需要的做的就是多使用像打印语句这样调试程序的方法找到问题所在，不必过于深究底层到底谁抢到了cpu，谁没抢到到的情况，毕竟学习的重点不在这种钻牛角尖 的问题，学会 熟练地实现线程安全的做法才是王道
    
43.                         r.setResource();
    
44.                         r.flag = true;
    
45.                         // try {
    
46.                         // Thread.sleep(1000);
    
47.                         // } catch (InterruptedException e) {
    
48.                         // e.printStackTrace();
    
49.                         // }
    
50.                         // System.out.println("pro....in");
    
51.                 }
    
52.                 // System.out.println("pro....out");
    
53.         }
    
54. }
    
55. 
    
56. class Consumer implements Runnable {
    
57.         Res r;
    
58. 
    
59.         Consumer(Res r) {
    
60.                 this.r = r;
    
61.         }
    
62. 
    
63.         public void run() {
    
64.                 while (true) {
    
65.                         if (r.flag) {
    
66.                                 r.getResource();
    
67.                                 r.flag = false;
    
68.                                 // try {
    
69.                                 // Thread.sleep(1000);
    
70.                                 // } catch (InterruptedException e) {
    
71.                                 // e.printStackTrace();
    
72.                                 // }
    
73.                                 // System.out.println("cus....in");
    
74.                         }
    
75.                         // System.out.println("cus....out");
    
76.                 }
    
77.         }
    
78. }

复制代码

？？？？？？？？

牛人，写这么长的代码，不错

不懂啊？帅哥QQ多少啊？