模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），只有盐买回来之后，妈妈才能继续做饭的过程。
class Mather{
    public void zuoFan(){
        System.out.println("做饭发现没盐了");
        new Son().start();
        System.out.println("继续做饭");
    }
}
class Son extends Thread{
    public void run(){
        Thread.sleep(3000);
    }
}

yong230 发表于 2013-1-16 17:19
楼主的 Thread.sleep(3000);这句不对吧，是以毫秒为单位的，休眠三分钟应该是Thread.sleep(3*60*1000); ...

是啊是啊，这点没注意到。

1. ackage com.itheima;
   
2. import java.lang.*;
   
3. /**
   
4. *
   
5. * 第10题、 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），
   
6. * 只有盐买回来之后，妈妈才能继续做饭的过程。
   
7. *  */
   
8. 
   
9. public class Test10
   
10. {
    
11.         /*
    
12.          这其实是线程间的通讯问题。盐是两个线程都需要操作的对象，建立独立的类，通过两个线程的构造函数传递进去
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                 // TODO Auto-generated method stub
    
16.                 Resource re =  new Resource();
    
17.                 new Thread(new Mum(re)).start();
    
18.                 new Thread(new Son(re)).start();
    
19. 
    
20. 
    
21.         }
    
22. 
    
23. }
    
24. class Mum implements Runnable
    
25. {
    
26.         private Resource s ;
    
27.         Mum(Resource s)
    
28.         {
    
29.                 this.s = s;
    
30.         }
    
31. 
    
32.         @Override
    
33.         public void run()
    
34.         {
    
35.                 // TODO Auto-generated method stub
    
36.                 //模拟两次
    
37.                 int x = 2;
    
38.                 while(x>0)
    
39.                 {
    
40.                         s.useSalt();
    
41.                         x--;
    
42.                 }
    
43.                
    
44.         }        
    
45.         
    
46. }
    
47. 
    
48. class Son implements Runnable
    
49. {
    
50.         private Resource s ;
    
51.         Son(Resource s)
    
52.         {
    
53.                 this.s = s;
    
54.         }
    
55. 
    
56.         @Override
    
57.         public void run()
    
58.         {
    
59.                 // TODO Auto-generated method stub
    
60.                 //模拟两次
    
61.                 int x = 2;
    
62.                 while(x>0)
    
63.                 {
    
64.                         s.buySalt();
    
65.                         x--;
    
66.                 }
    
67.         }
    
68.         
    
69. }
    
70. class Resource
    
71. {        
    
72.         //定义标记。
    
73.         public boolean hasSalt = false;
    
74.         public synchronized void useSalt()
    
75.         {        
    
76.                 if(!hasSalt)
    
77.                         try
    
78.                         {
    
79.                                 System.out.println("Mum:there is no salt,buy some ,son");
    
80.                                 wait();                                 
    
81.                         }
    
82.                         catch(Exception e)
    
83.                         {
    
84.                         }
    
85.                         System.out.println("Mum: I am cooking now------------");
    
86.                         hasSalt = false;
    
87.                         notifyAll();
    
88. 
    
89.                
    
90.                
    
91.         }
    
92.         public synchronized void buySalt()
    
93.         {        
    
94.                 if(hasSalt)
    
95.                         try
    
96.                         {                                
    
97.                                 wait();
    
98.                         }
    
99.                         catch(Exception e)
    
100.                         {
     
101.                         }
     
102.                
     
103.                 System.out.println("Son: I will go to buy some salt;");
     
104.                
     
105.                 try
     
106.                 {
     
107.                         Thread.currentThread().sleep(3*60*1000);
     
108.                 }
     
109.                
     
110.                 catch (Exception e)
     
111.                 {
     
112.                 }
     
113.                 System.out.println("Son: I have bought som salt,Mum -----");
     
114.                 hasSalt = true;
     
115.                 notifyAll();
     
116.                
     
117.         }
     
118.         
     
119. }

复制代码

哈哈，这是黑马基础测试题吧。我是这样答的。这里用到了专家模式（谁拥有资源，操作该资源的方法就归给谁。），因为盐单独成为一个类，所以操作盐的方法也封转到了盐（Res）这个资源类中。

楼主，你没发现你的代码运行结果是盐还没买回来，反已经继续做了啊，其实按照你说的要等儿子买盐回来在继续做饭，就是单线程，想药多线程的话，就应该让儿子去买盐，然后妈妈先做别的，等儿子买盐回来，在继续做饭。
class Mather{
    public void zuoFan(){
        System.out.println("做饭发现没盐了");
        new Son().start();
       System.out.println("做其它的，儿子买盐回来在继续做饭");
        
            }
}
class Son extends Thread{
    public void run(){
        Thread.sleep(180000);
       System.out.println("买盐归来，喊妈妈继续做饭");

    }
}

我不认为这是考多线程的问题   我觉得它主要是考对JAVA对象的认识
我是这么解决的：
package lianxi;

public class Demozuofan {

        /**
         * @param args
         * 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），只有盐买回来之后，妈妈才能继续做饭的过程。
         * @throws Exception

         */
        public static void main(String[] args) throws Exception {
                // TODO Auto-generated method stub
                //new Son().maiyan();
                new Mather().zuofan();
        }
        
}

class YanGuan
{
        private static int yan;

        public static int getYan() {
                return yan;
        }

        public static void setYan(int yan) {
                YanGuan.yan = yan;
        }
         
}
class Mather
{
        int yan = YanGuan.getYan();
        public void zuofan() throws Exception
        {
                while(yan==0)
                {
                        System.out.println("盐罐没盐了，儿子去买盐！");
                        new Son().maiyan();
                        yan = YanGuan.getYan();
                }
                System.out.println("妈妈做饭中...");
        }
}
class Son
{
        public void maiyan() throws InterruptedException
        {
                System.out.println("儿子买盐用了三分钟");
                YanGuan.setYan(10);
        }
}
只有盐买回来之后，妈妈才能继续做饭的过程  对于这句的理解：可以让线程停下 ，上面没有做  我用了输出语句表示 上面有while循环，只有有盐的情况下做饭才能接续

皇冠黑马哎 得注册多长时间了啊  哈哈

这个貌似是基础测试题吧,我做过一回,楼主最好这样以做饭为一个类来实现,其中有做饭和买盐两个方法,而有一个成员属性是boolean值,就是是否有盐,这样以盐是否有为监视器对象,同步两个方法就没问题了,再分别实现妈妈和儿子两个类,并且都实现Runnable,然后在run方法里分别调用买盐和做饭的方法，这样就比较妥当了。

楼主的 Thread.sleep(3000);这句不对吧，是以毫秒为单位的，休眠三分钟应该是Thread.sleep(3*60*1000);

题目出的是不太严谨，其实题目就是想考一下Thread.sleep()方法的使用而已
我的答案:
public class Test10 {
        public static void main(String[] args) {
                cook();
                System.out.println("做完饭了.....");
        }

        /*
         * 做饭
         */
        public static void cook() {
                System.out.println("妈妈开始做饭发现没盐了,让儿子去买盐.........");
                buySalt();
                System.out.println("妈妈继续做饭了.....");
               
        }
        /*
         * 买盐
         */
        public static void buySalt() {
                System.out.println("儿子去买盐了.....");
                try {
                        Thread.sleep(3*60*1000);//使当前线程休眠3分钟模拟买盐需要3分钟
                } catch (InterruptedException e) {
                        e.printStackTrace();
                        return;
                }
                System.out.println("儿子买盐回来了，妈妈继续做饭.....");
        }

}

把你的代码写完整吧。

改成妈妈知道盐没有了，做饭之前叫儿子去买盐 她去做菜  比较符合多线程的意义

这个题目跟本不符合多线程的意义

这个比法有趣，但是不贴切。
1.如果妈妈要等盐买回来才可以做饭。那么买盐这段时间妈妈什么事都不做。这样，是单线程。