黑马程序员技术交流社区

标题: 一个多线程问题，不知道我的答案对不对 [打印本页]
作者: 梁俊    时间: 2013-1-16 15:58
标题: 一个多线程问题，不知道我的答案对不对
本帖最后由 张向辉 于 2013-1-19 12:48 编辑

模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要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);
    }
}
作者: 黄嵘才    时间: 2013-1-16 16:09
这个比法有趣，但是不贴切。
1.如果妈妈要等盐买回来才可以做饭。那么买盐这段时间妈妈什么事都不做。这样，是单线程。
作者: 惠晖    时间: 2013-1-16 16:38
这个题目跟本不符合多线程的意义
作者: 惠晖    时间: 2013-1-16 16:40
改成妈妈知道盐没有了，做饭之前叫儿子去买盐 她去做菜  比较符合多线程的意义
作者: 王溢君    时间: 2013-1-16 16:40
把你的代码写完整吧。
作者: yong230    时间: 2013-1-16 17:15
题目出的是不太严谨，其实题目就是想考一下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("儿子买盐回来了，妈妈继续做饭.....");
        }

}
作者: yong230    时间: 2013-1-16 17:19
楼主的 Thread.sleep(3000);这句不对吧，是以毫秒为单位的，休眠三分钟应该是Thread.sleep(3*60*1000);
作者: 王阳    时间: 2013-1-16 22:45
这个貌似是基础测试题吧,我做过一回,楼主最好这样以做饭为一个类来实现,其中有做饭和买盐两个方法,而有一个成员属性是boolean值,就是是否有盐,这样以盐是否有为监视器对象,同步两个方法就没问题了,再分别实现妈妈和儿子两个类,并且都实现Runnable,然后在run方法里分别调用买盐和做饭的方法，这样就比较妥当了。
作者: Rancho_Gump    时间: 2013-1-17 15:47
皇冠黑马哎 得注册多长时间了啊  哈哈
作者: Rancho_Gump    时间: 2013-1-17 15:48
本帖最后由 张向辉 于 2013-1-17 15:59 编辑

我不认为这是考多线程的问题   我觉得它主要是考对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循环，只有有盐的情况下做饭才能接续
作者: 苏克    时间: 2013-1-18 16:19
楼主，你没发现你的代码运行结果是盐还没买回来，反已经继续做了啊，其实按照你说的要等儿子买盐回来在继续做饭，就是单线程，想药多线程的话，就应该让儿子去买盐，然后妈妈先做别的，等儿子买盐回来，在继续做饭。
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("买盐归来，喊妈妈继续做饭");

    }
}
作者: 朱玉玺    时间: 2013-1-20 10:27
本帖最后由 zyx67786110 于 2013-1-20 10:39 编辑
  1. ackage com.itheima;
  2. import java.lang.*;
  3. /**
  4. *
  5. * 第10题、 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），
  6. * 只有盐买回来之后，妈妈才能继续做饭的过程。
  7. *  */

  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();


  21.         }

  23. }
  24. class Mum implements Runnable
  25. {
  26.         private Resource s ;
  27.         Mum(Resource s)
  28.         {
  29.                 this.s = s;
  30.         }

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

  48. class Son implements Runnable
  49. {
  50.         private Resource s ;
  51.         Son(Resource s)
  52.         {
  53.                 this.s = s;
  54.         }

  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();

  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）这个资源类中。
作者: 朱玉玺    时间: 2013-1-20 10:37
yong230 发表于 2013-1-16 17:19
楼主的 Thread.sleep(3000);这句不对吧，是以毫秒为单位的，休眠三分钟应该是Thread.sleep(3*60*1000); ...

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



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