下面这个生产消费的例子，我是想暴露出wait()和notify()的在多个线程干一件事情时线程间通信的不足。我想看到的安全问题是生产两次消费一次或者生产两次消费一次。但是在执行过程中还出现了另一个问题就是一大片的销售没有生产，按代码上来执行应该是如果销售了没有生产，标志位是不会变的，是不会再销售的，为什么还会有那么多销售打出来呢？
下面是代码：请高手帮帮忙分析一下

1. class Goods        //定义商品类
   
2. {
   
3.         private String name;//商品的属性
   
4.         private int num = 0;//商品的编号
   
5.         boolean flag = false;//定义标志位，如果为真代表已生产商品，等待销售
   
6. 
   
7.         Goods(String name)        //构造函数
   
8.         {
   
9.                 this.name = name;
   
10.         }
    
11.         
    
12.         public  void Product()        //商品的生产
    
13.         {
    
14.                 synchronized(this)
    
15.                 {
    
16.                         if(flag)
    
17.                                 try{this.wait();}catch(Exception e){}//如果商品生产了则等待
    
18.                         System.out.println(Thread.currentThread().getName()+"Product \t"+this.name+"\t编号是"+(++num));
    
19.                         flag = true;
    
20.                         this.notify();
    
21.                 }
    
22.         }
    
23. 
    
24.         public  void Sell()        //商品的销售
    
25.         {
    
26.                 synchronized(this)
    
27.                 {
    
28.                         if(!flag)
    
29.                                 try{this.wait();}catch(Exception e){}//如果商品卖出了，则等待
    
30.                         System.out.println(Thread.currentThread().getName()+"Sell \t"+this.name+"\t编号是"+num);
    
31.                         flag = false;
    
32.                         this.notify();
    
33.                 }
    
34.         }
    
35. }
    
36. class Product implements Runnable        //商品生产的类
    
37. {
    
38.         Goods g;
    
39.         Product(Goods g)
    
40.         {
    
41.                 this.g = g;
    
42.         }
    
43.         public void run()
    
44.         {
    
45.                 while(true)
    
46.                 {
    
47.                         g.Product();
    
48.                 }
    
49.         }
    
50. }
    
51. class Sell implements Runnable        //商品销售的类
    
52. {
    
53.         Goods g;
    
54.         Sell(Goods g)
    
55.         {
    
56.                 this.g = g;
    
57.         }
    
58. 
    
59.         public void run()
    
60.         {
    
61.                 while(true)
    
62.                 g.Sell();
    
63.         }
    
64. }
    
65. class ProductSellDemo        //主函数
    
66. {
    
67.         public static void main(String[] args)
    
68.         {
    
69.                 Goods g = new Goods("IPhone");
    
70.                
    
71.                 new Thread(new Product(g)).start();//生产线程
    
72.                 new Thread(new Product(g)).start();
    
73. 
    
74.                 new Thread(new Sell(g)).start();//销售线程
    
75.                 new Thread(new Sell(g)).start();
    
76.         }
    
77. }

复制代码

下面是执行过程中的问题截图

因为线程不同步.

public  void Product()        
{
  synchronized(this)
  {
          while(flag)      //此处为while不应该为if，以便对唤醒的等待做出判断
                  try{this.wait();}catch(Exception e){}
          System.out.println(Thread.currentThread().getName()+"Product \t"+this.name+"\t编号是"+(++num));
          flag = true;
          this.notifyAll(); // 此处为notifyAll()唤醒该锁下的所有的线程，如为notify()则有可能唤醒仍为该区域
  }
}

public  void Sell()   
{
  synchronized(this)
  {
          while(!flag)     // 解释如上
                  try{this.wait();}catch(Exception e){}
          System.out.println(Thread.currentThread().getName()+"Sell \t"+this.name+"\t编号是"+num);
          flag = false;
          this.notifyAll();        // 解释如上
  }
}


建议仔细观看毕老师第12天课程！

strawberry2013 发表于 2013-3-23 10:57
public  void Product()        
{
  synchronized(this)

我知道啊，如果换成你修改后的代码就不会出现生产一次销售两次或者是生产两次销售一次的情况。我写这个代码就是为了让他暴露出安全问题。只是暴露的第二个问题，我不知道是怎么来的。按代码上来执行应该是如果销售了没有生产，标志位是不会变的，是不会再销售的，顶多是销售两次或者生产两次，为什么还会有那么多销售打出来呢？
看我上面的截图，我是不知道为什么会暴露第二个安全问题。

葛伟 发表于 2013-3-23 09:05
因为线程不同步.

能给我仔细分析一下吗？万分感谢。