这些天刚刚跟着毕老师窥探了一下多线程这个神秘的世界，自己动手编写了入学基础测试题的第十题(妈妈做饭的代码)，运行结果正常，可是还有一些困惑，下面贴上我的代码：
package com.itheima;

public class Test10 {
        /**
         *第10题:模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），只有盐买回来之后，妈妈才能继续做饭的过程。
         *
         * @author zhuxiaojie
         */
          public static void main(String[] args){
                  Salt salt = new Salt();
                  
                  Mother m = new Mother(salt);
                  Son s = new Son(salt);
                  
                  Thread mother = new Thread(m);
                  Thread son = new Thread(s);
                  
                  mother.start();
                  son.start();

                  //mother.setPriority(5);                  //mother.setPriority(1);
          }
}

//共享资源：盐类
class Salt{
        boolean flag = false;
}

//妈妈类
class Mother implements Runnable{
        private Salt salt;
        
        public Mother(Salt salt){
                this.salt = salt;
        }
        
        public void run() {
                while(true){
                        synchronized(salt){
                                if(!salt.flag){
                                        System.out.println("Mother:儿子，没有盐了，你去买盐吧！");
                                        salt.notify();//唤醒儿子去买盐
                                        try {
                                                salt.wait();//等待儿子把盐买回来
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }else{
                                        System.out.println("Mother:做饭中...儿子，待会就能吃饭了！");
                                        System.out.println();
                                        try {
                                                Thread.sleep(1*60*1000);//做饭需要时间
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                        salt.flag = false;//改变盐的状态：没盐
                                }
                        }
                }
        }
}

//儿子类
class Son implements Runnable{
        private Salt salt;
        
        public Son(Salt salt){
                this.salt = salt;
        }
        
        public void run() {
                while(true){
                        synchronized(salt){
                                if(!salt.flag){
                                        System.out.println("Son:妈妈，你等会，我现在就去买盐！");
                                        try {
                                                Thread.sleep(3*60*1000);//买盐需要三分钟
                                                salt.flag = true;//改变盐的状态:有盐
                                                System.out.println("Son:妈妈，盐买回来了，什么是否能吃饭啊？");
                                                salt.notify();//唤醒妈妈继续做饭
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                try {
                                        salt.wait();//等待吃饭
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
}


困惑一：怎么才能让儿子吃上饭呢？每次儿子买回盐来之后，就又得去买盐！
困惑二:程序运行结果的第一次 总是儿子先去买盐，可是我想让妈妈先执行，后来我想到了设置线程的优先级，但是不管用，请问该怎么处理？线程的优先级什么时候使用？数字越大代表优先级越高？
困惑三:根据题目的需求，我的代码还能怎么优化呢？请各位多多指教！谢谢！

题目的意思 是模拟做饭的过程。lz的代码运行结果是一直 在买盐，做饭。

• “困惑一：怎么才能让儿子吃上饭呢？每次儿子买回盐来之后，就又得去买盐！”，----儿子吃上饭，加一条打印语句就可以了。然后结束线程。
• “困惑二:程序运行结果的第一次 总是儿子先去买盐，可是我想让妈妈先执行，后来我想到了设置线程的优先级，但是不管用，请问该怎么处理？线程的优先级什么时候使用？数字越大代表优先级越高？” -----Java 线程模型涉及可以动态更改的线程优先级。本质上，线程的优先级是从 1 到 10 之间的一个数字，数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程，然后才调用优先级较低的线程。但是，该标准对具有相同优先级的线程的处理是随机的。如何处理这些线程取决于基层的操作系统策略。在某些情况下，优先级相同的线程分时运行；在另一些情况下，线程将一直运行到结束。请记住，Java 支持 10 个优先级，基层操作系统支持的优先级可能要少得多，这样会造成一些混乱。因此，只能将优先级作为一种很粗略的工具使用。最后的控制可以通过明智地使用 yield() 函数来完成。通常情况下，请不要依靠线程优先级来控制线程的状态。
• ”困惑三:根据题目的需求，我的代码还能怎么优化呢？请各位多多指教！谢谢！“ 在楼主代码基础上，我是这样改的。
  1. package org.cookingtest;
     
  2. 
     
  3. public class TestCooking {
     
  4.         /**
     
  5.          *第10题:模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），只有盐买回来之后，妈妈才能继续做饭的过程。
     
  6.          *
     
  7.          * @author jugs
     
  8.          */
     
  9.         public static void main(String[] args) {
     
  10.                 Salt salt = new Salt();
      
  11. 
      
  12.                 Mother m = new Mother(salt);
      
  13. 
      
  14.                 Thread mother = new Thread(m);
      
  15.                 mother.start();
      
  16. 
      
  17.                 // mother.setPriority(5); //mother.setPriority(1);
      
  18.         }
      
  19. }
      
  20. 
      
  21. // 共享资源：盐类
      
  22. class Salt {
      
  23.         boolean flag = false;
      
  24. }
      
  25. 
      
  26. // 妈妈类
      
  27. class Mother implements Runnable {
      
  28.         private Salt salt;
      
  29. 
      
  30.         public Mother(Salt salt) {
      
  31.                 this.salt = salt;
      
  32.         }
      
  33. 
      
  34.         public void run() {
      
  35.                 while (true) {
      
  36.                         synchronized (salt) {
      
  37.                                 if (!salt.flag) {
      
  38.                                         System.out.println("妈妈开始做饭了。");
      
  39.                                         System.out.println("Mother:儿子，没有盐了，你去买盐吧！");
      
  40.                                         Son s = new Son(salt);
      
  41.                                         Thread son = new Thread(s);
      
  42.                                         son.start();
      
  43.                                         try {
      
  44.                                                 salt.wait();// 等待儿子把盐买回来
      
  45.                                         } catch (InterruptedException e) {
      
  46.                                                 e.printStackTrace();
      
  47.                                         }
      
  48.                                         System.out.println("Mother:做饭中...儿子，待会就能吃饭了！");
      
  49.                                 }
      
  50.                                 System.out.println("妈妈做饭中");
      
  51.                                 try {
      
  52.                                         Thread.sleep(1000);// 做饭需要时间
      
  53.                                 } catch (InterruptedException e) {
      
  54.                                         e.printStackTrace();
      
  55.                                 }
      
  56.                                 System.out.println("Mother:儿子，吃饭了。");
      
  57.                         }
      
  58.                         break;
      
  59.                 }
      
  60.         }
      
  61. }
      
  62. 
      
  63. // 儿子类
      
  64. class Son implements Runnable {
      
  65.         private Salt salt;
      
  66. 
      
  67.         public Son(Salt salt) {
      
  68.                 this.salt = salt;
      
  69.         }
      
  70. 
      
  71.         public void run() {
      
  72.                 while (true) {
      
  73.                         synchronized (salt) {
      
  74.                                 if (!salt.flag) {
      
  75.                                         System.out.println("Son:妈妈，你等会，我现在就去买盐！");
      
  76.                                         try {
      
  77.                                                 Thread.sleep(1000);// 买盐需要三分钟
      
  78.                                                 salt.flag = true;// 改变盐的状态:有盐
      
  79.                                                 System.out.println("Son:妈妈，盐买回来了，什么是否能吃饭啊？");
      
  80.                                                 salt.notify();// 唤醒妈妈继续做饭
      
  81.                                         } catch (InterruptedException e) {
      
  82.                                                 e.printStackTrace();
      
  83.                                         }
      
  84.                                 }
      
  85.                         }
      
  86.                         break;
      
  87.                 }
      
  88.         }
      
  89. }

  复制代码
  以下我我写的。
  1. public class MaiYan02 {
     
  2.         public static void main(String[] args) {
     
  3.                 new Thread(new Mother()).start();
     
  4.         }
     
  5. }
     
  6. 
     
  7. class Mother implements Runnable {
     
  8.         public void run() {
     
  9.                 System.out.println("开始做饭了");
     
  10.                 System.out.println("妈妈说：\"没盐了，儿子，买盐去！\"");
      
  11.                 Thread son = new Thread(new Son());
      
  12.                 son.start();
      
  13.                 try {
      
  14.                         son.join();
      
  15.                 } catch (InterruptedException e) {
      
  16.                         e.printStackTrace();
      
  17.                 }
      
  18.                 System.out.println("盐买回来，妈妈继续做饭。");
      
  19.         }
      
  20. }
      
  21. 
      
  22. class Son implements Runnable {
      
  23.         public void run() {
      
  24.                 System.out.println("儿子：\"好的，马上去买盐！\"");
      
  25.                 try {
      
  26.                         Thread.sleep(3000);
      
  27.                 } catch (InterruptedException e) {
      
  28.                         e.printStackTrace();
      
  29.                 }
      
  30.         }
      
  31. }
      

  复制代码

鼓励一下！！！

何俊森 发表于 2013-4-17 11:17
题目的意思 是模拟做饭的过程。lz的代码运行结果是一直 在买盐，做饭。

“困惑一：怎么才能让儿子吃上 ...

作者的Salt类并没有什么实际用途啊？

朱晓杰 发表于 2013-4-17 13:29
作者的Salt类并没有什么实际用途啊？

对，那个忘删了。我那个没有想那么复杂，基本适合题目的意思。

何俊森 发表于 2013-4-17 14:32
对，那个忘删了。我那个没有想那么复杂，基本适合题目的意思。

恩恩，是了，我仔细分析了你的代码，挺简单的，只是我现在多线程只学习了一半，线程间的通信还没有完全掌握呢，谢谢你的回答，感觉自己对多线程的理解有加强了！