1. package ygc;
   
2. 
   
3. public class SuoDemo
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 Resource r = new Resource();
   
8.                 Put p = new Put(r);
   
9.                 Out o = new Out(r);
   
10. 
    
11.                 Thread t1 = new Thread(p,"生产1");
    
12.                 Thread t2 = new Thread(p,"生产2");
    
13.                 Thread t3 = new Thread(o,"消费");
    
14.                
    
15.                 t1.start();
    
16.                 t2.start();
    
17.                 t3.start();
    
18.         
    
19.         }
    
20. 
    
21. }
    
22. 
    
23. class Resource
    
24. {
    
25.         private String name;
    
26.         private int count = 1;
    
27.         private int x = 100;
    
28.         private boolean flag = false;
    
29.         
    
30.         public synchronized void set(String name)
    
31.         {
    
32.                 while(x>0)
    
33.                 {
    
34.                         if(flag)
    
35.                         {
    
36.                                 try
    
37.                                 {
    
38.                                         wait();
    
39.                                 }
    
40.                                 catch(Exception e){}
    
41.                         }
    
42. 
    
43.                         this.name = name + "-----" +count++;
    
44.                         System.out.println(Thread.currentThread().getName()+this.name);
    
45.                         flag = true;
    
46.                         x--;
    
47.                         this.notify();
    
48.                 }
    
49.         }
    
50. 
    
51.         public synchronized void out()
    
52.         {
    
53.                 while(x>0)
    
54.                 {
    
55.                         if(!flag)
    
56.                         {
    
57.                                 try
    
58.                                 {
    
59.                                         wait();
    
60.                                 }
    
61.                                 catch(Exception e)
    
62.                                 {
    
63. 
    
64.                                 }
    
65.                         }
    
66.                         System.out.println(Thread.currentThread().getName()+this.name);
    
67.                         flag = false;
    
68.                         this.notify();
    
69.                 }
    
70.         }
    
71. }
    
72. 
    
73. class Put implements Runnable
    
74. {
    
75.         private Resource r;
    
76.         Put(Resource r)
    
77.         {
    
78.                 this.r = r;
    
79.         }
    
80.         public void run()
    
81.         {
    
82.                 r.set("物品");
    
83.         }
    
84. }
    
85. 
    
86. class Out implements Runnable
    
87. {
    
88. 
    
89.         private Resource r;
    
90.         Out(Resource r)
    
91.         {
    
92.                 this.r = r;
    
93.         }
    
94.         public void run()
    
95.         {
    
96.                 r.out();
    
97.         }
    
98. }
    

复制代码

生产2物品-----26
生产1物品-----27
消费物品-----27
为什么会出现这样的结果，一个Put的线程操作完不是应该out的线程操作，put的另一个线程因为锁上进不来么，怎么会put的线程操作了两次呢
在一个线程冻结的时候，另一个不是因为锁上无法操作了么
每次好像想到点子上了，头脑就自己绕浆糊了，思路又乱了，各位帮忙看一下

class Resource
{
        private String name;
        private int count = 1;
        private boolean flag = false;

        public synchronized void set(String name)
        {       
                if(flag)
                        try{this.wait();}catch(Exception e){}
                this.name = name+"---"+count++;
                System.out.println(Thread.currentThread().getName()+"...生产者...."+this.name);
                flag = true;
                this.notify();
        }

        public synchronized void out()
        {
                if(!flag)
                        try{this.wait();}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"...消费者......."+this.name);
                flag = false;
                this.notify();
        }
}

class Producer implements Runnable
{
        private Resource res;

        Producer(Resource res)
        {
                this.res = res;
        }

        public void run()
        {
                while(true)
                {
                        res.set("+商品+");
                }
        }
}

class Consumer implements Runnable
{
        private Resource res;
       
        Consumer(Resource res)
        {
                this.res = res;
        }

        public void run()
        {
                while(true)
                {
                        res.out();
                }
        }
}


class ProducerConsumerDemo
{
        public static void main(String[] args)
        {
                Resource r = new Resource();

                Producer pro = new Producer(r);
                Consumer con = new Consumer(r);

                Thread t1 = new Thread(pro);
                Thread t2 = new Thread(pro);
                Thread t3 = new Thread(con);
                //Thread t4 = new Thread(con);//注释了这个当你put了2个的时候，就要对应的2个out去消费，当你只有一个的时候out的时候却要去生产2个，你加了锁就说明一定要2个都生产完才可以out。

                t1.start();
                t2.start();
                t3.start();
                //t4.start();//和上面都一样。
               
        }
}


这是我运行的结果，和你那个是一样的。
Thread-0...生产者....+商品+---74
Thread-1...生产者....+商品+---75
Thread-2...消费者.......+商品+---75
Thread-0...生产者....+商品+---76
Thread-1...生产者....+商品+---77
Thread-2...消费者.......+商品+---77
Thread-0...生产者....+商品+---78
Thread-1...生产者....+商品+---79