黑马程序员技术交流社区

标题: 多线程关于生产者和消费着的问题 [打印本页]
作者: 舍我其谁    时间: 2014-8-10 12:25
标题: 多线程关于生产者和消费着的问题
用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;

  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.         }

  21. }

  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. }

  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. }

  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. }
复制代码
作者: 陶圣虎    时间: 2014-8-10 13:51
代码有两个问题：
1.notify（） 只唤醒一个。 有可能出现唤醒己方线程的情况 从而造成己方线程全部等到。要换位notifyAll（）
2.if判断一次。唤醒己方多次操作。应该换位while。
作者: fantacyleo    时间: 2014-8-10 14:00
谁说用if最多生产2次消费1次的？线程一旦失去约束，完全可能被执行3次、4次才切换到其他线程
作者: alvinbx    时间: 2014-8-10 14:52
一楼说的没错，给你我写的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();
                        }
               
        }
}
作者: 舍我其谁    时间: 2014-8-10 17:37
fantacyleo 发表于 2014-8-10 14:00
谁说用if最多生产2次消费1次的？线程一旦失去约束，完全可能被执行3次、4次才切换到其他线程 ...

不是有标记吗？怎么还会失去约束
作者: dispensable    时间: 2014-8-10 19:14
:L楼上都答非所问，楼主请看API文档对notify（）方法的说明：唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。
看到了吗？选择是任意性的，也就是说最坏最坏的情况下有可能出现10000个生产者才会消费一个
作者: fantacyleo    时间: 2014-8-10 20:20
舍我其谁 发表于 2014-8-10 17:37
不是有标记吗？怎么还会失去约束

有标记没用啊，唤醒是全部唤醒，你把while改成了if，醒后就不再判断标记直接往下运行
作者: 舍我其谁    时间: 2014-8-10 20:28
dispensable 发表于 2014-8-10 19:14
楼上都答非所问，楼主请看API文档对notify（）方法的说明：唤醒在此对象监视器上等待的单个线程。如果所 ...

哦，谢谢，受教了



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2