用编程实现“模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐
（假设买盐需要3分钟），只有盐买回来之后，妈妈才能
继续做饭的过程。”这个应该具体怎么实现？这是我的最后一道试题
原来不会写，请大家一起分析一下吧？

我们这学期的java课上 老师给我们出过这个题!  
正确代码:

1. public class Test {
   
2. 
   
3.         static class Mother extends Thread{
   
4.                 /** 盐的用量 */
   
5.                 final int SaltUseage = 40;
   
6.                 volatile boolean cooking = true;
   
7.                 Home home;
   
8.                 public void run(){
   
9.                         try {
   
10.                                 while(cooking){
    
11.                                         Salt salt = home.salt;
    
12.                                         if(salt.value<SaltUseage){
    
13.                                                 home.son.buySalt();
    
14.                                                 waiting();
    
15.                                         }
    
16.                                         System.out.println("[妈妈]盐  ==>> 当前量："+salt.value+" 用去量:"+SaltUseage+" 剩余量："+(salt.value-SaltUseage));
    
17.                                         salt.value -= SaltUseage;
    
18.                                         otherThings();
    
19.                                 }
    
20.                         } catch (Exception e) {
    
21.                                 cooking = false;
    
22.                         }
    
23.                 }
    
24.                 private void otherThings() {
    
25.                         try {
    
26.                                 sleep(1000);
    
27.                         } catch (Exception e) {
    
28.                                 cooking = false;
    
29.                         }
    
30.                 }
    
31.                 private synchronized void waiting() throws InterruptedException {
    
32.                         System.out.println("[妈妈]盐  ==>> 当前量："+home.salt.value+"  等待儿子去买盐。");
    
33.                         home.mother.wait();
    
34.                 }
    
35.                 private synchronized void notice(){
    
36.                         home.mother.notify();
    
37.                 }
    
38.         }
    
39.         static class Son extends Thread{
    
40.                 /** 盐的购买量 */
    
41.                 final int SaltPurchases = 60;
    
42.                 volatile boolean free = true;
    
43.                 Home home;
    
44.                 public void run(){
    
45.                         try {
    
46.                                 while(free){
    
47.                                         waiting();
    
48.                                         sleep(2000);
    
49.                                         System.out.println("[儿子]盐  ==>> 当前量："+home.salt.value+" 购买量:"+SaltPurchases+" 剩余量："+(home.salt.value+SaltPurchases));
    
50.                                         home.salt.value += SaltPurchases;
    
51.                                         notice();
    
52.                                 }
    
53.                         } catch (Exception e) {
    
54.                                 free = false;
    
55.                         }
    
56.                 }
    
57.                 public synchronized void buySalt(){
    
58.                         notify();
    
59.                 }
    
60.                 private void notice() {
    
61.                         System.out.println("[儿子]盐  ==>> 当前："+home.salt.value+" 盐已买到。");
    
62.                         home.mother.notice();
    
63.                 }
    
64.                 private synchronized void waiting() throws InterruptedException {
    
65.                         System.out.println("[儿子]盐  ==>> 当前："+home.salt.value+" 等下次买。");
    
66.                         wait();
    
67.                 }
    
68.         }
    
69.         static class Salt{
    
70.                 int value = 90;
    
71.         }
    
72.         static class Home{
    
73.                 Mother mother = new Mother();
    
74.                 Son son = new Son();
    
75.                 Salt salt = new Salt();
    
76.                 public Home(){
    
77.                         mother.home = this;
    
78.                         son.home = this;
    
79.                 }
    
80.                 public void startCooking(){
    
81.                         mother.start();
    
82.                         son.start();
    
83.                 }
    
84.                 public void stopCooking(){
    
85.                         mother.cooking=false;
    
86.                         son.free=false;
    
87.                         mother.interrupt();
    
88.                         son.interrupt();
    
89.                 }
    
90.         }
    
91.         
    
92.         /**
    
93.          * Test
    
94.          */
    
95.         public static void main(String[] args) throws Exception {
    
96.                 Home home = new Home();
    
97.                 home.startCooking();
    
98.                 Thread.sleep(15000);
    
99.                 home.stopCooking();
    
100.         }
     
101. 
     
102. }

复制代码

其实就是一个多线程同步的问题，执行权的释放以及唤醒，你去参考一下生产者消费者问题，其实你这个题目就用那个模版就行了。