/**
* 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），
* 只有盐买回来之后，妈妈才能继续做饭的过程。
*
*/
public class test10 {
public static void main(String[] args){
  Mother mother=new Mother();
  new Thread(mother).start();
}
}
class Mother implements Runnable{
boolean cooking=true;
static int salt=0;
@Override
public void run() {
  // TODO Auto-generated method stub
  while(cooking){
   if(salt==0) //判断出盐不够了，下面继续执行
   {
    System.out.println("做饭没有盐了，让儿子出去买盐！！");
    Son son=new Son(); //创建son的实例化对象
    son.buySalt();//用son的实例化对象调用son类内部的方法，叫儿子去买盐
   
   }
   System.out.println("儿子买盐回来，妈妈继续做饭...");
  }
}

}
class Son extends Thread{
boolean s = true;
public void run(){
  System.out.println("儿子出去买盐，用了三分钟后回来了。");
  while(s){
   try{
    sleep(180);//儿子出去买盐三分钟。
   }
   catch(InterruptedException e){
    e.printStackTrace();
   }   
   s=false;
  }
}
public synchronized void buySalt() // 创建买盐方法，buSalt。
{
  Son son=new Son();
  son.start();
}

}

运行的时候结果不停的重复，跟死循环似的，请大家帮我看一下代码有什么问题？应该怎么修改呢？ 谢谢大家啊。

黑马云青年再打酱油{:soso_e130:}

神之梦 发表于 2013-5-18 11:59
黑马云青年再打酱油

:hug: 黑马云青年求问题， 弱弱的说一句，大家不要嫌弃我问的低级哦，嘿嘿

你的休眠时间不对，应该是1000*60*3，再一个你了解一下线程的周期和执行，不然那个打印顺序会有错误。还有你没有设置Mother的线程的标示cooking，所以它会一直执行。下面是我改后的代码，你参考一下。

1. /**
   
2. * 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟）， 只有盐买回来之后，妈妈才能继续做饭的过程。
   
3. *
   
4. */
   
5. public class test10 {
   
6. public static void main(String[] args) {
   
7. Mother mother = new Mother();
   
8. new Thread(mother).start();
   
9. }
   
10. }
    
11. 
    
12. class Mother implements Runnable {
    
13. boolean cooking = true;
    
14. static int salt = 0;
    
15. public void run() {
    
16. // TODO Auto-generated method stub
    
17. while (cooking) {
    
18. if (salt == 0) // 判断出盐不够了，下面继续执行
    
19. {
    
20. System.out.println("做饭没有盐了，让儿子出去买盐！！");
    
21. Son son = new Son(); // 创建son的实例化对象
    
22. son.buySalt();// 用son的实例化对象调用son类内部的方法，叫儿子去买盐
    
23. System.out.println("儿子出去买盐，用了三分钟后回来了。");
    
24. }
    
25. System.out.println("儿子买盐回来，妈妈继续做饭...");
    
26. cooking=false;
    
27. }
    
28. }
    
29. 
    
30. }
    
31. 
    
32. 
    
33. class Son extends Thread {
    
34. boolean s = true;
    
35. public void run() {
    
36. while (s) {
    
37. try {
    
38. Thread.sleep(1000*60*3);// 儿子出去买盐三分钟。
    
39. } catch (InterruptedException e) {
    
40. e.printStackTrace();
    
41. }
    
42. s = false;
    
43. }
    
44. }
    
45. 
    
46. public synchronized void buySalt() // 创建买盐方法，buSalt。
    
47. {
    
48. Son son = new Son();
    
49. son.start();
    
50. }
    
51. 
    
52. }
    

复制代码

王盟盟 发表于 2013-5-18 12:30
while(s){
   try{
    sleep(180);//儿子出去买盐三分钟。  你这是180毫秒，不是3分钟。3分钟是1000*60*3

哦哦，对哦， 180后面再乘以1000就行了。
可是这样也不行呀，代码还是运行结果不对，运行的像个死循环一样，哪位能够解答一下。

余威宏 发表于 2013-5-18 12:45
哦哦，对哦， 180后面再乘以1000就行了。
可是这样也不行呀，代码还是运行结果不对，运行的像个死循环一 ...

我重新回复你了，你看看

boolean cooking=true;
static int salt=0;
@Override
public void run() {
  // TODO Auto-generated method stub
  while(cooking){……}

while的循环条件cooking为true，循环就会继续执行。而你程序里面cooking的值一直没有改变，所以程序会无限循环

介系个入学基础测试的题目！

黑马云青年我表示先打个酱油，刚搞完两篇学习日记
肚子饿得凶。。。

chouwayメ 发表于 2013-5-18 15:41
。。。
妈妈的属性的布尔数据 cooking一直是true.你没有哪个步聚把 cooking变成false.
妈妈一直在循环黑马 ...

嗯，我也发现了是有一个子线程没有开启。 哥们有没有更好的办法优化一下呢。

1. /**
   
2. * 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），
   
3. * 只有盐买回来之后，妈妈才能继续做饭的过程。
   
4. *
   
5. */
   
6. public class test10
   
7. {
   
8.           public static void main(String[] args)
   
9.         {
   
10.              Mother mother=new Mother();
    
11.               new Thread(mother).start();
    
12.         }
    
13. }
    
14. 
    
15. 
    
16. class Mother implements Runnable
    
17. {
    
18.        boolean cooking=true;
    
19.        static int salt=0;
    
20. public void run() {
    
21.   // TODO Auto-generated method stub
    
22.   while(cooking){
    
23.    if(salt==0) //判断出盐不够了，下面继续执行
    
24.    {
    
25.     System.out.println("做饭没有盐了，让儿子出去买盐！！");
    
26.     Son son =new Son(); //创建son的实例化对象
    
27.     son.start();//用son的实例化对象调用son类内部的方法，叫儿子去买盐
    
28.     }
    
29.    System.out.println("儿子买盐回来，妈妈继续做饭...");
    
30.   cooking=false;
    
31.    }
    
32. }
    
33. 
    
34. }
    
35. 
    
36. class Son extends Thread{
    
37.                 boolean s = true;
    
38.                 public void run(){
    
39.                 buySalt(); }    //   run方法中就只放个buySalt就一动作。
    
40.                 public  
    
41. <span style="background-color: rgb(255, 255, 255); ">synchronized</span> void buySalt() // 创建买盐方法，buSalt。
    
42.              {
    
43.                 System.out.println("儿子出去买盐，用了三分钟后回来了。");
    
44.                 while(s){
    
45.                 try{
    
46.                     sleep(180);}//儿子出去买盐三分钟; }
    
47.                 catch(InterruptedException e){ e.printStackTrace();
    
48.                      }   
    
49.                   s=false;}
    
50.                  }
    
51.            }

复制代码

mother的cooking一直是true啊

改动主要有：
        1. 儿子的run方法中的内容改成buySalt();   
         把买盐方法封装成具体代码，提高代码复用性。
        2.mother run方法中添加
           Son son=new Son son;
           son.start();
          末尾添加 cooking=false.
----
代码粗略的改了。应该还可以优化啦
---------
黑马云青年为您解答。

如果问题已解决请再次编辑，改为以解决，方便大家看帖