用if判断标记，不是最多也就生产两次消费一次，或者生产一次，消费两次吗？可我的运行结果怎么会这样？请大神指点
Thread-0 生产者电视机...57327
Thread-1..消费者...电视机...57327
Thread-0 生产者电视机...57328
Thread-3..消费者...电视机...57328
Thread-2 生产者电视机...57329
Thread-0 生产者电视机...57330
Thread-3..消费者...电视机...57330
Thread-1..消费者...电视机...57330
Thread-3..消费者...电视机...57330
Thread-1..消费者...电视机...57330
Thread-0 生产者电视机...57331
Thread-2 生产者电视机...57332
Thread-3..消费者...电视机...57332
Thread-0 生产者电视机...57333
Thread-2 生产者电视机...57334
Thread-0 生产者电视机...57335
Thread-2 生产者电视机...57336
Thread-0 生产者电视机...57337
Thread-2 生产者电视机...57338
Thread-0 生产者电视机...57339
Thread-2 生产者电视机...57340
Thread-0 生产者电视机...57341
Thread-2 生产者电视机...57342
Thread-0 生产者电视机...57343
代码如下：

1. package MyCode;
   
2. 
   
3. public class MyLock {
   
4.         public static void main(String[] args) {
   
5.                 ChangPin cp=new ChangPin();//商品对象
   
6.                 Sheng s=new Sheng(cp);//生产者对象
   
7.                 Xiao x=new Xiao(cp);//消费者对象
   
8.                 //创建线程
   
9.                 Thread t1=new Thread(s);
   
10.                 Thread t2=new Thread(x);
    
11.                 Thread t3=new Thread(s);
    
12.                 Thread t4=new Thread(x);
    
13.                 //开启线程
    
14.                 t1.start();
    
15.                 t2.start();
    
16.                 t3.start();
    
17.                 t4.start();
    
18.                
    
19.         }
    
20. 
    
21. }
    
22. 
    
23. class ChangPin
    
24. {
    
25.   private String name; //商品名称
    
26.   private int count;//次数
    
27.   boolean flag=false;//标记
    
28.   public synchronized void setName(String name)
    
29.   {
    
30.                   if(flag)
    
31.                   {
    
32.                                   try {
    
33.                                         this.wait();
    
34.                                 } catch (InterruptedException e) {
    
35.                                         e.printStackTrace();
    
36.                                 }
    
37.                   }
    
38.                   this.name=name+"..."+count++;
    
39.                   System.out.println(Thread.currentThread().getName()+" 生产者"+this.name);
    
40.                   flag=true;
    
41.                   this.notify();
    
42.                   
    
43.           
    
44.   }  
    
45.   
    
46.   public synchronized void outName()
    
47.   {
    
48.           if(!flag)
    
49.           {
    
50.                           try {
    
51.                                 this.wait();
    
52.                         } catch (InterruptedException e) {
    
53.                                 e.printStackTrace();
    
54.                         }
    
55.           }
    
56.           System.out.println(Thread.currentThread().getName()+"..消费者..."+this.name);
    
57.           flag=false;
    
58.           this.notify();
    
59.   }
    
60. }
    
61. 
    
62. class Sheng implements Runnable
    
63. {
    
64.         private ChangPin cp;
    
65.         public Sheng(ChangPin cp)
    
66.         {
    
67.                 this.cp=cp;
    
68.         }
    
69.        
    
70.         public void run()
    
71.         {
    
72.                 while(true)
    
73.                 cp.setName("电视机");
    
74.         }
    
75. }
    
76. 
    
77. class Xiao implements Runnable
    
78. {
    
79.         private ChangPin cp;
    
80.         public Xiao(ChangPin cp)
    
81.         {
    
82.                 this.cp=cp;
    
83.         }
    
84.    public void run()
    
85.    {
    
86.            while(true)
    
87.            cp.outName();
    
88.    }
    
89. }
    

复制代码

代码有两个问题：
1.notify（） 只唤醒一个。 有可能出现唤醒己方线程的情况 从而造成己方线程全部等到。要换位notifyAll（）
2.if判断一次。唤醒己方多次操作。应该换位while。

谁说用if最多生产2次消费1次的？线程一旦失去约束，完全可能被执行3次、4次才切换到其他线程

一楼说的没错，给你我写的recourse代码参考，用lock写的。
public class Res {
        private String name;
        private String sex;
        private boolean flag=false;
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
        public void Set(String name,String sex) throws InterruptedException{
                lock.lock();
                        try {
                                while(flag)
                                condition.await();
                                this.name = name;
                                this.sex = sex;
                                System.out.println(Thread.currentThread().getName()+"生产者");
                                flag =true;
                                condition.signalAll();
                        }finally{
                                lock.unlock();
                        }
        }
        public void show() throws InterruptedException{
                lock.lock();
                        try {
                                while(!flag)
                                condition.await();
                                System.out.println("名字"+name+"性别"+sex+Thread.currentThread().getName());
                                flag = false;
                                condition.signalAll();
                        }finally{
                                lock.unlock();
                        }
               
        }
}

fantacyleo 发表于 2014-8-10 14:00
谁说用if最多生产2次消费1次的？线程一旦失去约束，完全可能被执行3次、4次才切换到其他线程 ...

不是有标记吗？怎么还会失去约束

:L楼上都答非所问，楼主请看API文档对notify（）方法的说明：唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。
看到了吗？选择是任意性的，也就是说最坏最坏的情况下有可能出现10000个生产者才会消费一个

舍我其谁 发表于 2014-8-10 17:37
不是有标记吗？怎么还会失去约束

有标记没用啊，唤醒是全部唤醒，你把while改成了if，醒后就不再判断标记直接往下运行

dispensable 发表于 2014-8-10 19:14
楼上都答非所问，楼主请看API文档对notify（）方法的说明：唤醒在此对象监视器上等待的单个线程。如果所 ...

哦，谢谢，受教了