这段代码为什么会停止循环呢？

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. }

复制代码

136616244 发表于 2014-5-7 20:12
你QQ多少  我运行给你看看

2564673498 。我想看下，正在学习中。

sheng6699 发表于 2014-5-7 20:06
我想问一下，楼主代码出现什么错误了，代码在我电脑上没出现异常，或停止啊 ...

你QQ多少  我运行给你看看

136616244 发表于 2014-5-7 18:09
没明白，qq多少啊？

我想问一下，楼主代码出现什么错误了，代码在我电脑上没出现异常，或停止啊:)

Lin0411 发表于 2014-5-7 17:07

我想问一下，楼主代码出现什么错误了，代码在我电脑上没出现异常，或停止啊:)

Lin0411 发表于 2014-5-7 17:43

没明白，qq多少啊？

1. public class test {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                Res r = new Res();
   
6.   
   
7.                Producer p = new Producer(r);
   
8. 
   
9.                Consumer c = new Consumer(r);
   
10. 
    
11.                Thread t = new Thread(p);
    
12.                
    
13.                Thread t2 = new Thread(c);
    
14.                
    
15.                t.start();
    
16.       
    
17.                 t2.start();
    
18. 
    
19. 
    
20. 
    
21.        }
    
22. 
    
23. }
    
24. 
    
25. class Res
    
26. {
    
27. 
    
28.        public boolean flag = false;
    
29. 
    
30.        private int count = 0;
    
31. 
    
32.         public  synchronized void setResource()
    
33.         {
    
34. 
    
35.                                 count++;
    
36.                               System.out.println(Thread.currentThread().getName()+"生产者------"+count);
    
37.                 }
    
38.      
    
39. 
    
40.        public synchronized void getResource()
    
41.        {
    
42. 
    
43. 
    
44.                                                   System.out.println(Thread.currentThread().getName()+"消费者。"+"。。。。。。。。。。。"+count);
    
45. 
    
46.                }   
    
47. 
    
48. 
    
49.        }
    
50. 
    
51. 
    
52. 
    
53. class Producer implements Runnable
    
54. {
    
55. 
    
56.        Res r;
    
57. 
    
58.        Producer(Res r )
    
59.        {
    
60.               this.r = r;
    
61. 
    
62.        }
    
63. 
    
64.        public void run()
    
65.        {
    
66.                while(true)
    
67.                {
    
68.                        if(!r.flag)
    
69.                        {
    
70.                                r.setResource();
    
71.                                r.flag = true;
    
72.                        }
    
73.                        try
    
74.                        {
    
75. 
    
76.                                Thread.sleep(100);
    
77.                         } catch (Exception e) {
    
78.                         }
    
79.                }
    
80.         }
    
81. 
    
82. }
    
83. 
    
84. class Consumer implements Runnable
    
85. {
    
86. 
    
87.        Res r;
    
88. 
    
89.        Consumer(Res r)
    
90.        {
    
91. 
    
92.                 this.r = r;
    
93.                
    
94.        }
    
95. 
    
96.        public void run()
    
97.        {
    
98.                while(true)
    
99.                {
    
100.                        if(r.flag)
     
101.                        {
     
102.                                r.getResource();
     
103.                                r.flag =false;
     
104.                        }
     
105.                        try {
     
106.                                Thread.sleep(100);
     
107.                         } catch (Exception e) {
     
108.                                 e.printStackTrace();
     
109.                         }
     
110.                }
     
111.               
     
112.         }
     
113. 
     
114. }
     
115. 
     
116. 如果硬是要用lz的代码，就要在生产者执行完setSouce释放所后，自己有充分的时间去设置flag而不用得到下次自己得到cpu时间后再来设置flag值，消费者也如此，如果不这样，程序运行太快，同步范围又太窄，就容易出现相互等待的问题。
     

复制代码

136616244 发表于 2014-5-7 17:13
我想问的是   生产者消费者拿到cpu的执行权不是随机的吗，为什么需要唤醒等待呢？
我的问题出在哪了

唤醒等待主要是用来进行线程间通信，就像生产者-消费者问题一样，生产者生产一个物品，就唤醒消费者去拿刚生产的物品，当他发现消费者还没有取走上一次生产的物品时，就进入睡眠状态，等消费者取走物品后，消费者便将生产者唤醒，生产者继续生产物品，同样，消费者如果发现没有物品可拿，便进入等待状态，等生产者生产出一个物品之后，就将消费者唤醒，消费者就去取物品。这就完成线程间的通信。

Lin0411 发表于 2014-5-7 17:07

我想问的是   生产者消费者拿到cpu的执行权不是随机的吗，为什么需要唤醒等待呢？
我的问题出在哪了

1. 这样就没问题了。
   
2. 
   
3. public class test {
   
4. 
   
5.         public static void main(String[] args) {
   
6. 
   
7.                Res r = new Res();
   
8.   
   
9.                Producer p = new Producer(r);
   
10. 
    
11.                Consumer c = new Consumer(r);
    
12. 
    
13.                Thread t = new Thread(p);
    
14.                
    
15.                Thread t2 = new Thread(c);
    
16.                
    
17.                t2.start();
    
18.       
    
19.                 t.start();
    
20. 
    
21. 
    
22. 
    
23.        }
    
24. 
    
25. }
    
26. 
    
27. class Res
    
28. {
    
29. 
    
30.        private boolean flag = false;
    
31. 
    
32.        private int count = 0;
    
33. 
    
34.         public  void setResource()
    
35.         {
    
36. 
    
37.                 while(true)
    
38.                 {
    
39.                         synchronized(Res.class)
    
40.                         {
    
41.                                 if(!flag)
    
42.                                 {
    
43.                                 count++;
    
44.                               System.out.println(Thread.currentThread().getName()+"生产者------"+count);
    
45.                               flag = true;
    
46.                             }
    
47.                         }
    
48.                 }
    
49.         }
    
50. 
    
51.        public  void getResource()
    
52.        {
    
53. 
    
54.                while(true)
    
55.                {
    
56.                        synchronized(Res.class)
    
57.                                {
    
58.                                     if(flag)
    
59.                                           {
    
60.                                                   System.out.println(Thread.currentThread().getName()+"消费者。"+"。。。。。。。。。。。"+count);
    
61.                                                   flag = false;
    
62.                                           }
    
63.                                }
    
64. 
    
65.                }   
    
66. 
    
67.        }
    
68. 
    
69. }
    
70. 
    
71. class Producer implements Runnable
    
72. {
    
73. 
    
74.        Res r;
    
75. 
    
76.        Producer(Res r )
    
77.        {
    
78.               this.r = r;
    
79. 
    
80.        }
    
81. 
    
82.        public void run()
    
83.        {
    
84.                r.setResource();
    
85.         }
    
86. 
    
87. }
    
88. 
    
89. class Consumer implements Runnable
    
90. {
    
91. 
    
92.        Res r;
    
93. 
    
94.        Consumer(Res r)
    
95.        {
    
96. 
    
97.                 this.r = r;
    
98.                
    
99.        }
    
100. 
     
101.        public void run()
     
102.        {
     
103.                r.getResource();
     
104.               
     
105.         }
     
106. 
     
107. }
     

复制代码