1. /*
   
2. 生产者-消费者模式练习
   
3. 用同步机制解决生产和消费信息不统一的问题
   
4. 用等待与唤醒机制实现生产一个消费一个
   
5. */
   
6. 
   
7. 
   
8. class  PmakeCus
   
9. {
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 Resouse r = new Resouse();//产品
    
13.                 Make m = new Make(r);//生产者
    
14.                 Customer c = new Customer(r);//消费者
    
15.                 new Thread(m,"生产线程1").start();//线程
    
16.                 new Thread(m,"生产线程2").start();
    
17.                 new Thread(m,"生产线程3").start();
    
18.                 new Thread(m,"生产线程4").start();
    
19.                 new Thread(c,"消费线程1").start();
    
20.                 new Thread(c,"消费线程2").start();
    
21.                 new Thread(c,"消费线程3").start();
    
22.                 new Thread(c,"消费线程4").start();
    
23.         }
    
24. }
    
25. 
    
26. //产品类
    
27. class Resouse
    
28. {
    
29.         private String pname;//产品名称
    
30.         private int pcount = 1;//产品标识
    
31.         private Boolean flag ;//等待判断标识  = false;
    
32. 
    
33. //生产产品
    
34.         public synchronized void pset(String pname)//同步生产
    
35.         {
    
36.                 while(flag)//已生产产品
    
37.                 {
    
38.                         try
    
39.                         {
    
40.                                 this.wait();       
    
41.                         }
    
42.                         catch (Exception e)
    
43.                         {
    
44.                                 e.printStackTrace();
    
45.                         }
    
46.                 }
    
47.                 this.pname=pname+"--"+pcount++;
    
48.                 System.out.println(Thread.currentThread().getName()+"--生产者--"+this.pname);
    
49.                 flag = true;//重新设置等待标识
    
50.                 this.notifyAll();//唤醒所有
    
51.         }
    
52. 
    
53. //消费产品
    
54.         public synchronized void pget()//同步取出
    
55.         {
    
56.                 while(!flag)//已取出产品
    
57.                 {
    
58.                         try
    
59.                         {
    
60.                                 this.wait();       
    
61.                         }
    
62.                         catch (Exception e)
    
63.                         {
    
64.                                 e.printStackTrace();
    
65.                         }
    
66.                 }
    
67.                 System.out.println(Thread.currentThread().getName()+"..消费者.."+this.pname);
    
68.                 flag = false;//重新设置等待标识
    
69.                 this.notifyAll();//唤醒所有               
    
70.         }
    
71. }
    
72. 
    
73. //生产类
    
74. class Make implements Runnable
    
75. {
    
76.         private Resouse r;
    
77.         Boolean f = true;
    
78.         Make(Resouse r)
    
79.         {
    
80.                 this.r=r;//接受同一产品资源
    
81.         }
    
82.         public void run()
    
83.         {
    
84.                 while(true)
    
85.                 {
    
86.                         if(f)
    
87.                         {
    
88.                                 r.pset("终结者I型");//生产不同产品
    
89.                                 f=false;
    
90.                         }
    
91.                         else
    
92.                         {
    
93.                                 r.pset("终结者II型");//生产不同产品
    
94.                                 f=true;
    
95.                         }
    
96. 
    
97.                 }
    
98.         }
    
99. }
    
100. 
     
101. //消费类
     
102. class Customer implements Runnable
     
103. {
     
104.         private Resouse r;
     
105.         Customer(Resouse r)
     
106.         {
     
107.                 this.r=r;//接受同一产品资源
     
108.         }
     
109.         public void run()
     
110.         {
     
111.                 while(true)
     
112.                 {
     
113.                         r.pget();//取出产品
     
114.                 }
     
115.         }
     
116. }
     

复制代码

Boolean flag必须附上初始值private Boolean flag = false，否则运行报空指针，为什么呢？
我记得类成员Booleand的默认值是false
类成员的话，private Boolean flag = false；和private Boolean flag；会有不同吗？

Boolean不是8种基本类型，它是boolean的包装类，是类类型。默认初始化是null，使用之前必须引用一个对象，所以会发送空指针异常。
Boolean falg = false;编译器帮你自动装箱，相当于 Boolean  flag = new Boolean(false);

kerner 发表于 2014-11-27 17:39
Boolean不是8种基本类型，它是boolean的包装类，是类类型。默认初始化是null，使用之前必须引用一个对象， ...

谢谢啊，原来写成了包装类了

我就说感觉不对，基本数据类型boolean这样才对啊，，，，