package test.first;

public class Test1 {
       

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Production p = new Production();
                new Thread(new Product(p)).start();
                new Thread(new Consumption(p)).start();

        }

}

class Production{
        public  String name;
        public  boolean isExist;
        public Production() {
                this.isExist = false;
        }
}
class Product implements Runnable{
        private Production p;
        Product(Production p){
                this.p = p;
        }
        @Override
        public void run() {
                // TODO Auto-generated method stub
                int i = 0;
                while(true){

                                if(!p.isExist){
                                        p.name = "baozi_"+i;
                                        p.isExist = true;
                                        System.out.println("生产一个"+p.name+p.isExist);
                                        i++;
                                }

       

                }
               
        }
       
}
class Consumption implements Runnable{
        private Production p;
        public Consumption(Production p) {
                // TODO Auto-generated constructor stub
                this.p = p;

        }

        @Override
        public void run() {
                // TODO Auto-generated method stub
                while(true){

                                if(p.isExist){
                                       
                                        p.isExist =false;
                                        System.out.println("消费一个:"+p.name+p.isExist);
                                }
       
                }
               
        }
}
程序目的：生产者生产一个，消费者便消费一个
理想运行结果：生产一个，消费一个
已经理解的错误：会出现连续生产3个，2个，或消费3个，2个，或者先消费再生产，原因：争夺共享资源isExist造成的
无法理解的错误：程序运行后不就会进入阻塞状态无法继续下去，控制台只出现不定量的几行运行结果
求解释啊

仔细琢磨

楼主你好。

这题的问题在于多线程的安全问题。为了保证多线程的安全，一般都会使用同步代码块或同步方法。
俗称“锁”。
以下附件是我在楼主代码基础上增加了同步代码块，请参考一下。

以下从Product的run代码中简单说明一下，若看不明白请回头再看看毕老师11天的讲课内容：

public void run() {
                // TODO Auto-generated method stub
                int i = 0;
                while(true){
                        if(p.isExist == false){
                                synchronized(this.p){-------------------------------此处的代码即为访问共用变量的同步代码块，为了保证访问唯一性而上锁
                                        p.name = "baozi_"+i;
                                        p.isExist = true;
                                        System.out.println("生产一个"+p.name+p.isExist);
                                        i++;

                        }
                }
        }

代码一多看起来就好迷茫

旅人の影 发表于 2014-12-7 17:26
楼主你好。

这题的问题在于多线程的安全问题。为了保证多线程的安全，一般都会使用同步代码块或同步方法。 ...

这个我知道加锁，我的问题在于，在不加锁的情况下，也不应该出现只打印几行数据就不在再打印的情况啊

那是因为你的p.isExist如果是true而生产者抢到CPU执行权，它就不打印生产，而在不停的执行while循环，有点像死循环；反之p.isExist是false而消费者抢到CPU执行权就是消费者里的while不停执行。就像while里面是空代码就是死循环一样了。就直接把CPU给拖死了不。    跟死循环有差别是有一方能进入if里面去打印程序还是可以执行的，在循环体里面加上sleep就可以让CPU不那么累，也就可以往下执行了。比如：

1. public class Test1 {
   
2.         public static void main(String[] args) {
   
3.                 Production p = new Production();
   
4.                 new Thread(new Product(p)).start();
   
5.                 new Thread(new Consumption(p)).start();
   
6.         }
   
7. }
   
8. 
   
9. class Production {
   
10.         public String name;
    
11.         public boolean isExist;
    
12. 
    
13.         public Production() {
    
14.                 this.isExist = false;
    
15.         }
    
16. }
    
17. 
    
18. class Product implements Runnable {
    
19.         private Production p;
    
20. 
    
21.         Product(Production p) {
    
22.                 this.p = p;
    
23.         }
    
24.         public void run() {
    
25.                 int i = 0;
    
26.                 while (true) {
    
27.                         try {
    
28.                                 Thread.sleep(30);
    
29.                         } catch (InterruptedException e) {
    
30.                                 e.printStackTrace();
    
31.                         }
    
32.                         if (!p.isExist) {
    
33.                                 p.name = "baozi_" + i;
    
34.                                 p.isExist = true;
    
35.                                 System.out.println("生产一个" + p.name + p.isExist);
    
36.                                 i++;
    
37.                         }
    
38.                 }
    
39. 
    
40.         }
    
41. 
    
42. }
    
43. 
    
44. class Consumption implements Runnable {
    
45.         private Production p;
    
46.         public Consumption(Production p) {
    
47.                 this.p = p;
    
48.         }
    
49.         public void run() {
    
50.                 while (true) {
    
51.                         try {
    
52.                                 Thread.sleep(30);
    
53.                         } catch (InterruptedException e) {
    
54.                                 e.printStackTrace();
    
55.                         }
    
56.                         if (p.isExist) {
    
57.                                 p.isExist = false;
    
58.                                 System.out.println("消费一个:" + p.name + p.isExist);
    
59.                         }
    
60.                 }
    
61.         }
    
62. }

复制代码

还没学习到，受教!!!!!!!!!!

你得有个锁  因为cpu的随机性 可能每次都是生产分配到  你就用锁强制让他在不该他走的时候让他停住  然后把锁释放出来  让消费用了之后才让他好使   然后又开始随即抢cpu  这时候如果消费抢到 他又挂住   把锁丢出来   让生产得到

1. import java.util.concurrent.locks.Condition;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4. 
   
5. 
   
6. class Money{
   
7.        
   
8.         private String name;
   
9.         private String sum;
   
10.         private int count=1;
    
11.         private int num=1;
    
12.         private boolean flag = false;
    
13.         private Lock lock=new ReentrantLock();
    
14.         private Condition condition_set=lock.newCondition();
    
15.         private Condition condition_get=lock.newCondition();
    
16.         public void Set(String name)throws Exception{
    
17.                 lock.lock();
    
18.                 while(flag)
    
19.                         condition_set.await();
    
20.                 this.name=name+".."+(count++)+"美元";
    
21.                 System.out.println(Thread.currentThread().getName()+"....."+this.name);
    
22.                 flag=true;
    
23.                 condition_get.signal();
    
24.                 lock.unlock();
    
25.         }
    
26.         public void Get(String name)throws Exception{
    
27.                 lock.lock();
    
28.                 while(!flag)
    
29.                         condition_get.await();
    
30.                 this.sum=name+(num++)+"美元";
    
31.                 System.out.println(Thread.currentThread().getName()+this.sum);
    
32.                 flag=false;
    
33.                 condition_set.signal();
    
34.                 lock.unlock();
    
35.         }
    
36.        
    
37. }
    
38. class Set implements Runnable{
    
39.          private Money money ;
    
40.                
    
41.                  Set(Money money){
    
42.                         this.money = money;
    
43.                 }
    
44.         @Override
    
45.         public void run() {
    
46.                 // TODO Auto-generated method stub
    
47.                 try {
    
48.                         while(true)
    
49.                         money.Set("捡钱");
    
50.                 } catch (Exception e) {
    
51.                         // TODO Auto-generated catch block
    
52.                         e.printStackTrace();
    
53.                 }
    
54.                
    
55.         }
    
56.        
    
57. }
    
58. class Get implements Runnable{
    
59.         private Money money;
    
60.          Get(Money money){
    
61.                 this.money=money;
    
62.         }
    
63.         public void run(){
    
64.                 try {
    
65.                         while(true)
    
66.                         money.Get("用钱");
    
67.                 } catch (Exception e) {
    
68.                         // TODO Auto-generated catch block
    
69.                         e.printStackTrace();
    
70.                 }
    
71.         }
    
72. }
    
73. public class SetGEetDemo {
    
74.         public static void main(String[] args){
    
75.                
    
76.                 Money money =new Money();
    
77.                 Set s = new Set(money);
    
78.                 Get g = new Get(money);
    
79.                 Thread t1 =new Thread(s);
    
80.                 Thread t2 =new Thread(s);
    
81.                 Thread t3 =new Thread(s);
    
82.                 Thread t4 =new Thread(g);
    
83.                 Thread t5 =new Thread(g);
    
84.                 Thread t6 =new Thread(g);
    
85.                 t1.start();
    
86.                 t2.start();
    
87.                 t3.start();
    
88.                 t4.start();
    
89.                 t5.start();
    
90.                 t6.start();
    
91.         }
    
92.        
    
93.        
    
94. 
    
95. }
    

复制代码

恩 我运行也会出现同样的问题，只出现几行代码，有时多点，有时少点。至于为什么卡主了我想是因为cpu只执行其中一个线程而忽略了另一个，而这个执行的线程因为标记是false，所以while循环体是空所以没有输出了。

消费的时候使用 条件对象 可以解决

fatesabering 发表于 2014-12-9 11:01
恩 我运行也会出现同样的问题，只出现几行代码，有时多点，有时少点。至于为什么卡主了我想是因为cpu只执行 ...

就你看懂了我问的是啥，我是在问，问题出在哪里，其他人都回答怎么解决~ ~！。。。。不过你这个原因也说不过去吧，cpu怎么会一直卡在一个线程上，这个原因不太可能吧，也许是多线程执行while（true）{}空循环时的一些特殊机制吧，因为如果在if后加上else输出一句话（也就是不让它出现空循环的情况），那么这个程序就不会卡死

lh994749769 发表于 2014-12-9 12:26
就你看懂了我问的是啥，我是在问，问题出在哪里，其他人都回答怎么解决~ ~！。。。。不过你这个原因也说 ...

恩 有道理，估计是这样