A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 隐藏归类 › 黑马那些年 › 第53,54,55,56,57届Android交流区 › 正文

王震阳老师【阳哥专栏】黑马程序员技术分活动第31期，讨论

© 邓士林 高级黑马   /  2015-1-9 11:19  /  2201 人查看  /  4 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 邓士林 于 2015-1-26 17:23 编辑

题目连接黑马程序员技术分活动第31期，昨天看到这题，自己也琢磨了。
根据毕老师的讲解，我们是将生产和消费定义在了资源产品类中，这样可以简化很多判断和变量的定义。
具体代码体现：
  1. /*
  2. 等待的目的是让cpu给其他线程。
  3. */  
  4. class Resource  
  5. {  
  6.     private String name;  
  7.     private int count = 0;  
  8.     private boolean flag = false;  
  9.     Resource(String name)  
  10.     {  
  11.         this.name = name;  
  12.     }  
  13.   
  14.     public synchronized void product()  
  15.     {  
  16.         while(flag)                     //此处如果是if的效果  
  17.         {  
  18.             try  
  19.             {  
  20.                 wait();  
  21.             }  
  22.             catch (InterruptedException ex)  
  23.             {  
  24.                   
  25.             }  
  26.         }  
  27.   
  28.         this.name = "---"+this.count;  
  29.         System.out.println(Thread.currentThread().getName() + "生产者---" + this.name);  
  30.         flag  = true;  
  31.         this.count++;  
  32.         this.notify();  
  33.     }  
  34.       
  35.     public synchronized void consume()  
  36.     {  
  37.         while(!flag)                    //此处如果是if的效果,如果某个线程被wait，接着又一个，然后两个都醒了，就会造成对一个产品两次消费  
  38.         {  
  39.             try  
  40.             {  
  41.                 wait();  
  42.             }  
  43.             catch (InterruptedException ex)  
  44.             {  
  45.             }  
  46.         }  
  47.   
  48.         System.out.println(Thread.currentThread().getName() + "消费者---------" + this.name);  
  49.         flag = false;  
  50.         this.notify();  
  51.     }  
  52. }  
  53.   
  54. class Product implements Runnable  
  55. {  
  56.     private Resource sr;  
  57.     Product(Resource sr)  
  58.     {  
  59.         this.sr = sr;  
  60.     }  
  61.   
  62.     public void run()  
  63.     {  
  64.         while(true)  
  65.         {  
  66.             if(sr != null)  
  67.             {  
  68.                 sr.product();  
  69.             }  
  70.         }  
  71.     }  
  72. }  
  73.   
  74. class Consume implements Runnable  
  75. {  
  76.     private Resource sr;  
  77.     Consume(Resource sr)  
  78.     {  
  79.         this.sr = sr;  
  80.     }  
  81.   
  82.     public void run()  
  83.     {  
  84.         while(true)  
  85.         {  
  86.             if(sr != null)  
  87.             {  
  88.                 sr.consume();  
  89.             }  
  90.         }  
  91.     }  
  92. }  
  93. class DemoRunnable  
  94. {  
  95.     public static void main(String[] args)   
  96.     {  
  97.         Resource sr = new Resource("产品");  
  98.         Product p = new Product(sr);  
  99.         Consume c =new Consume(sr);  
  100.         Thread t1 = new Thread(p);  
  101.         Thread t2 = new Thread(p);  
  102.         Thread c1 = new Thread(c);  
  103.         Thread c2 = new Thread(c);  
  104.         Thread c3 = new Thread(c);  
  105.         t1.start();  
  106.         t2.start();  
  107.         c1.start();  
  108.         c2.start();  
  109.         c3.start();  
  110.     }  
  111. }
复制代码

4 个回复

倒序浏览
邓士林 高级黑马 2015-1-9 11:21:29
| 只看该作者
沙发
本帖最后由 邓士林 于 2015-1-9 11:22 编辑

下面请教大家的问题是，如果我把生产和消费定义在线程中去控制，而不是在资源产品类中进行控制，出现问题：
代码如下：
  1. class Resource
  2. {
  3.         private int id;
  4.         public boolean flag = false;//没产品
  5.         public String name;
  6.         Resource(int id)
  7.         {
  8.                 this.id = id;
  9.         }

  11.         public void setId(int id)
  12.         {
  13.                 this.id = id;
  14.         }
  15.         public int getId()
  16.         {
  17.                 return this.id;
  18.         }
  19. }
  20. class Product implements Runnable
  21. {
  22.         private Resource rs = null;
  23.         private int id = 0;
  24.         Product(Resource rs)
  25.         {
  26.                 this.rs = rs;
  27.         }

  29.         public void run()
  30.         {
  31.                 synchronized(this)                                //this.getClass()
  32.                 {
  33.                         while(true)
  34.                         {
  35.                                 if(rs.flag)
  36.                                 {
  37.                                         try
  38.                                         {
  39.                                                 this.wait();
  40.                                         }
  41.                                         catch (InterruptedException ex)
  42.                                         {
  43.                                         }
  44.                                 }

  46.                                 rs.name = ""+rs.getId();
  47.                                 System.out.println(Thread.currentThread().getName() + "生产一个产品，产品号：" +
  48.                                 rs.name);
  49.                                 rs.setId(++id);
  50.                                 rs.flag = true;        
  51.                                 this.notify();//有产品了
  52.                         }
  53.                 }
  54.         }
  55. }

  57. class Consum implements Runnable
  58. {
  59.         private Resource rs = null;
  60.         Consum(Resource rs)
  61.         {
  62.                 this.rs = rs;
  63.         }

  65.         public void run()
  66.         {
  67.                 synchronized(this)            //this.getClass()
  68.                 {
  69.                         while(true)
  70.                         {
  71.                                 if(!rs.flag)                                //没产品，等待，不进行消费
  72.                                 {
  73.                                         try
  74.                                         {
  75.                                                 this.wait();
  76.                                         }
  77.                                         catch (InterruptedException ex)
  78.                                         {
  79.                                         }
  80.                                 }
  81.                                 System.out.println(Thread.currentThread().getName() + "取出一个产品，产品号：" +
  82.                                 rs.name);
  83.                                 rs.flag = false;
  84.                                 this.notify();
  85.                         }
  86.                 }
  87.         }
  88. }

  90. class ThreadTest
  91. {
  92.         public static void main(String [] args)
  93.         {
  94.                 Resource rs =new Resource(0);
  95.                 Product p = new Product(rs);
  96.                 Consum c = new Consum(rs);
  97.                 Thread tp1 = new Thread(p);
  98.                 Thread tp2 = new Thread(p);
  99.                 Thread tc1 =new Thread(c);
  100.                 Thread tc2 =new Thread(c);
  101.                 Thread tc3 =new Thread(c);

  103.                 tp1.start();
  104.                 tp2.start();
  105.                 tc1.start();
  106.                 tc2.start();
  107.                 tc3.start();

  109.         }
  110. }
复制代码

ddd.png (11.03 KB, 下载次数: 32)

ddd.png
回复 使用道具 举报
godmmm 高级黑马 2015-1-9 11:55:31
| 只看该作者
藤椅
本帖最后由 godmmm 于 2015-1-9 12:04 编辑

应该是锁加错了，this表示的本类，这样你的生存者用的是一个类锁，消费者用的是另一个锁，这样切换不了，你用资源这个锁试试。
回复 使用道具 举报
邓士林 高级黑马 2015-1-9 12:12:45
| 只看该作者
板凳
godmmm 发表于 2015-1-9 11:55
应该是锁加错了，this表示的本类，这样你的生存者用的是一个类锁，消费者用的是另一个锁，这样切换不了，你 ...

我知道，可是没想明白如何做呢
回复 使用道具 举报
godmmm 高级黑马 2015-1-9 13:31:25
| 只看该作者
报纸
你等待和唤醒的是this对象，这就错了，应该是锁这个对象
等待唤醒机制wait和notify只能是同一个对象
  1. class Resource {
  2.         private int id;
  3.         public boolean flag = false;// 没产品
  4.         public String name;

  6.         Resource(int id) {
  7.                 this.id = id;
  8.         }

  10.         public void setId(int id) {
  11.                 this.id = id;
  12.         }

  14.         public int getId() {
  15.                 return this.id;
  16.         }
  17. }
  18. class Product implements Runnable {
  19.         private Resource rs = null;
  20.         private int id = 0;

  22.         Product(Resource rs) {
  23.                 this.rs = rs;
  24.         }

  26.         public void run() {
  27.                 for(;;)
  28.                 {
  29.                         set();
  30.                 }
  31.         }
  32.         public  void set()
  33.         {
  34.                 synchronized(rs.getClass())
  35.                 {
  36.                         while (true) {
  37.                                 if (rs.flag)
  38.                                 {
  39.                                         try {rs.getClass().wait();} catch (InterruptedException ex) {}
  40.                                 }
  41.                                
  42.                                 rs.name = "" + rs.getId();
  43.                                 System.out.println(Thread.currentThread().getName()+ "生产一个产品，产品号：" + rs.name);
  44.                                 rs.setId(++id);
  45.                                 rs.flag = true;
  46.                                 rs.getClass().notify();// 有产品了
  47.                         }
  48.                 }
  49.         }
  50. }

  52. class Consum implements Runnable {
  53.         private Resource rs = null;

  55.         Consum(Resource rs) {
  56.                 this.rs = rs;
  57.         }

  59.         public void run() {
  60.                 for(;;)
  61.                 {
  62.                         get();
  63.                 }
  64.         }
  65.         public  void get()
  66.         {
  67.                 synchronized(rs.getClass())
  68.                 {
  69.                         while (true) {
  70.                                 if (!rs.flag) // 没产品，等待，不进行消费
  71.                                 {
  72.                                         try {rs.getClass().wait();} catch (InterruptedException ex) {}
  73.                                 }
  74.                                 System.out.println(Thread.currentThread().getName()        + "取出一个产品，产品号：" + rs.name);
  75.                                 rs.flag = false;
  76.                                 rs.getClass().notify();
  77.                         }
  78.                 }
  79.         }
  80. }

  82. class ThreadTest {
  83.         public static void main(String[] args) {
  84.                 Resource rs = new Resource(0);
  85.                 Product p = new Product(rs);
  86.                 Consum c = new Consum(rs);
  87.                 Thread tp1 = new Thread(p);
  88.                 Thread tp2 = new Thread(p);
  89.                 Thread tc1 = new Thread(c);
  90.                 Thread tc2 = new Thread(c);
  91.                 Thread tc3 = new Thread(c);

  93.                 tp1.start();
  94.                 tp2.start();
  95.                 tc1.start();
  96.                 tc2.start();
  97.                 tc3.start();

  99.         }
  100. }
复制代码
回复 使用道具 举报
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马