1. <div class="blockcode"><blockquote>package com.itheima;
   
2. 
   
3. /**
   
4. * 第10题： 模拟妈妈做饭，做饭时发现没有盐了，
   
5. * 让儿子去买盐（假设买盐需要3分钟），只有盐买回来之后，妈妈才能继续做饭的过程。
   
6. * @author Lihsh
   
7. *
   
8. */
   
9. public class Test10 {
   
10.         /**
    
11.          * 测试类实现主方法，用来测试程序
    
12.          * @param args
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                 new Thread(new MotherCooking("Mom" , false)).start(); //mum做饭
    
16.         }
    
17. }
    
18. /**
    
19. * 思路：Mum在做饭，发现没盐了，调动儿子的线程，去买盐；
    
20. * 此时,调用son的join()方法，让mum的线程在儿子的线程执行结束之后再执行。
    
21. * @author Lihsh
    
22. *
    
23. */
    
24. class MotherCooking implements Runnable{
    
25.         private boolean hasSalt;
    
26.         private String name;
    
27.         public MotherCooking(String name , boolean hasSalt) {
    
28.                 this.name = name;
    
29.                 this.hasSalt = hasSalt;
    
30.         }
    
31.         @Override
    
32.         public void run() {
    
33.                 System.out.println("Mother is cooking...");
    
34.                 while(!hasSalt) { //no salt is true
    
35.                         System.out.println("Jim , come here and help mum to buy some salt... ");
    
36.                         //调用son，让son去买盐
    
37.                         try {
    
38.                                 Thread t1 = new Thread(new SonBuySalt("Jim",false));
    
39.                                 t1.start();
    
40.                                 t1.join();
    
41.                         } catch (InterruptedException e) {
    
42.                                 e.printStackTrace();
    
43.                         }
    
44.                         hasSalt = true;
    
45.                 }
    
46.                 if(hasSalt){ //买的盐的话，那就接着做饭，(能成循环中跳出来，那自然就是买到盐了 hasSalt is true)
    
47.                         System.out.println("Thanks ,I will continue to cook...");
    
48.                 }
    
49.         }
    
50. }
    
51. 
    
52. /**
    
53. * 描述：son买盐的功能类，当Mum调用时启动。
    
54. * 通过标志位isBuyed(是否买的盐)来控制线程的执行。
    
55. * @author Lihsh
    
56. *
    
57. */
    
58. class SonBuySalt implements Runnable {
    
59.         private String name;
    
60.         private boolean isBuyed;//买到盐与否
    
61.         
    
62.         public SonBuySalt(){}
    
63.         public SonBuySalt(String name , boolean isBuyed)
    
64.         {
    
65.                 this.name = name;
    
66.                 this.isBuyed = isBuyed;
    
67.         }
    
68.         @Override
    
69.         public void run() {
    
70.                 System.out.println("OK , Mum!"); //去买盐了
    
71.                 while(!isBuyed){
    
72.                         try {
    
73.                                 Thread.sleep(3 * 60 * 1000);
    
74.                         } catch (InterruptedException e) {
    
75.                                 e.printStackTrace();
    
76.                         }
    
77.                         isBuyed = true;
    
78.                 }               
    
79.                 if(isBuyed){
    
80.                         System.out.println("Mum , I have bought salt...");
    
81.                 }
    
82.         }        
    
83. }

复制代码

运行结果：
Mother is cooking...
Jim , come here and help mum to buy some salt...
OK , Mum!
Mum , I have bought salt...
Thanks ,I will continue to cook...

好像逻辑就应该是这样的吧，我是不敢确定，求同志门指点！
更新了一下代码。

可以呀，加点注释，要不看起来费劲
还有答题要注意啊三点
1.把思路写上去
2.注释要详细
3.运行要正常

我手心里的宝 发表于 2013-4-7 11:03
可以呀，加点注释，要不看起来费劲
还有答题要注意啊三点
1.把思路写上去

嗯，谢谢，我稍微修改了一下代码，我是在想这里面需不需要同步synchronized呢？不知道，比较纠结。。。

这个就可以理解为消费者与生产者的例子
需要同步，不建议使用join方法
思路：设计两个线程
线程一：妈妈做饭
线程二：儿子买烟
过程三分钟可以用wait();来实现
里面加上时间就可以了 我的建议哈 使用同步

我手心里的宝 发表于 2013-4-7 12:55
这个就可以理解为消费者与生产者的例子
需要同步，不建议使用join方法
思路：设计两个线程

这个为什么需要同步?可能我对这个思路不是很理解.能否详细解释下,因为我觉得,如果没有盐,那做饭的线程应该是暂停的,然后执行买盐的线程,不冲突啊!

许兵兵 发表于 2013-4-7 17:20
这个为什么需要同步?可能我对这个思路不是很理解.能否详细解释下,因为我觉得,如果没有盐,那做饭的线程应 ...

我也是这样想的，比较困惑。

我手心里的宝 发表于 2013-4-7 12:55
这个就可以理解为消费者与生产者的例子
需要同步，不建议使用join方法
思路：设计两个线程

求解释为啥需要同步？

我同意上面的用2个线程来实现，做饭没盐了去买盐，继续做饭，又没盐了又去买盐。这就跟生产者消费者一样。下面用同步写的

1. public class BuySalt {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 Salt salt = new Salt();
   
9.                 Mun mun = new Mun(salt);
   
10.                 Son son = new Son(salt);
    
11.                 new Thread(mun).start();
    
12.                 new Thread(son).start();
    
13.         }
    
14. 
    
15. }
    
16. class Salt
    
17. {
    
18.         private boolean hassalt=true;
    
19.         public void saltUse()
    
20.         {
    
21.                 System.out.println("正在使用盐");
    
22.         }
    
23.         public void saltBuy()
    
24.         {
    
25.                 System.out.println("正在买盐");
    
26.         }
    
27.         public void setSalt(Boolean hassalt)
    
28.         {
    
29.                 this.hassalt=hassalt;
    
30.         }
    
31.         public boolean getSalt()
    
32.         {
    
33.                 return hassalt;
    
34.         }
    
35. }
    
36. class Mun implements Runnable
    
37. {
    
38.         private Salt salt;
    
39.         Mun(Salt salt)
    
40.         {
    
41.                 this.salt=salt;
    
42.         }
    
43.         public void run()
    
44.         {
    
45.                 while(true)
    
46.                 {
    
47.                         synchronized(salt)
    
48.                         {
    
49.                                 if(!salt.getSalt())
    
50.                                         try {
    
51.                                                 salt.wait();
    
52.                                         } catch (InterruptedException e) {
    
53.                                                 // TODO Auto-generated catch block
    
54.                                                 e.printStackTrace();
    
55.                                         }
    
56.                                 System.out.println("有盐了，妈妈做饭");
    
57.                                 salt.saltUse();                       
    
58.                                 try {
    
59.                                         Thread.sleep(5000);
    
60.                                 } catch (InterruptedException e) {
    
61.                                         // TODO Auto-generated catch block
    
62.                                         e.printStackTrace();
    
63.                                 }
    
64.                                 salt.setSalt(false);
    
65.                                 System.out.println("儿子，盐用光了,去买盐");
    
66.                                 salt.notify();                       
    
67.                         }
    
68.                 }
    
69.         }
    
70.        
    
71. }
    
72. class Son implements Runnable
    
73. {
    
74.         private Salt salt;
    
75.         Son(Salt salt)
    
76.         {
    
77.                 this.salt=salt;
    
78.         }
    
79.         public void run()
    
80.         {
    
81.                 while(true)
    
82.                 {
    
83.                         synchronized(salt)
    
84.                         {
    
85.                                 if(salt.getSalt())
    
86.                                         try {
    
87.                                                 salt.wait();
    
88.                                         } catch (InterruptedException e) {
    
89.                                                 // TODO Auto-generated catch block
    
90.                                                 e.printStackTrace();
    
91.                                         }
    
92.                                 System.out.println("好的，妈妈，我这就买盐去");
    
93.                                 try {
    
94.                                         Thread.sleep(5000);
    
95.                                 } catch (InterruptedException e) {
    
96.                                         // TODO Auto-generated catch block
    
97.                                         e.printStackTrace();
    
98.                                 }
    
99.                                 salt.saltBuy();
    
100.                                 System.out.println("妈妈，盐买回来了，你做饭吧");
     
101.                                 salt.setSalt(true);
     
102.                                 salt.notify();
     
103.                         }
     
104.                 }       
     
105.         }
     
106. }

复制代码

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢

我觉得这个可以理解成两个 单线程的 生产者 消费者，妈妈做饭没有盐，唤醒儿子线程去买盐，妈妈等待，儿子买盐回来，唤醒妈妈线程做饭，儿子等待.

HM朱俊 发表于 2013-4-7 19:29
我同意上面的用2个线程来实现，做饭没盐了去买盐，继续做饭，又没盐了又去买盐。这就跟生产者消费者一样。 ...

谢谢啊，明白了，应该就是生产者消费者模型，我的做法太局限了。

李大伟 发表于 2013-4-7 21:31
我觉得这个可以理解成两个 单线程的 生产者 消费者，妈妈做饭没有盐，唤醒儿子线程去买盐，妈妈等待，儿子 ...

嗯，明白了。