1. public class Test10 {
   
2. public static void main(String[] args)
   
3. {
   
4. 
   
5. Salt s = new Salt();
   
6. 
   
7. new Thread(new Mom(s)).start();
   
8. new Thread(new Son(s)).start();
   
9. }
   
10. }
    
11. class Salt{
    
12. boolean flag = false;
    
13. }
    
14. class Mom implements Runnable
    
15. {
    
16. private Salt s;
    
17. Mom(Salt s)
    
18. {
    
19. this.s = s;
    
20. }
    
21. public void run()
    
22. {
    
23. while(true){
    
24. synchronized(s){
    
25. if(s.flag){
    
26. try{s.wait(1000);}
    
27. catch(Exception e){}
    
28. System.out.println("妈妈说：没盐了，儿子，买盐去！没法做饭了");
    
29. s.flag = true;
    
30. s.notify();
    
31. }
    
32. 
    
33. 
    
34. }
    
35. }
    
36. }
    
37. }
    
38. class Son implements Runnable{
    
39. private Salt s;
    
40. Son(Salt s)
    
41. {
    
42. this.s = s;
    
43. }
    
44. public void run()
    
45. {
    
46. while(true){
    
47. synchronized(s){
    
48. if(!s.flag)
    
49. try{s.wait();}catch(Exception e){}
    
50. System.out.println("好的，马上去买盐！！！");
    
51. s.flag = false;
    
52. s.notify();
    
53. }
    
54. }
    
55. }
    
56. }

复制代码

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

复制代码

没有太明白楼主的代码，private Salt s, s.notify();什么意思。买盐的问题可以参考一下以上代码。

1. /**
   
2. * 模拟妈妈做饭，做饭时发现没有盐了，让儿子去买盐（假设买盐需要3分钟），只有盐买回来之后，妈妈才能继续做饭的过程。
   
3. *
   
4. *
   
5. */
   
6. public class Test10 {
   
7.         public static void main(String[] args) {
   
8.                 // 定义做饭的对象
   
9.                 final Cook c = new Cook();
   
10.                 // 定义一个妈妈做饭的线程，并启动
    
11.                 new Thread(new Runnable() {
    
12.                         public void run() {
    
13.                                 while (true) {
    
14.                                         c.makeCook();
    
15.                                 }
    
16.                         }
    
17.                 }).start();
    
18.                 // 定义一个儿子买盐的线程，并启动
    
19.                 new Thread(new Runnable() {
    
20.                         public void run() {
    
21.                                 while (true) {
    
22.                                         c.buySalt();
    
23.                                 }
    
24.                         }
    
25.                 }).start();
    
26.         }
    
27. }
    
28. 
    
29. /**
    
30. * 因为妈妈儿子需要用到相同的锁对象，和相同的是否能做饭的标示对戏那个，所以把他们封装在一个类中的两个方法中。
    
31. */
    
32. class Cook {
    
33.         // 是否能做饭的标识
    
34.         private boolean canCook = false;
    
35. 
    
36.         /**
    
37.          * 妈妈做饭的方法
    
38.          */
    
39.         public synchronized void makeCook() {
    
40.                 // 如果没有盐，就等待3分钟，唤醒儿子去买盐。
    
41.                 if (!canCook) {
    
42.                         System.out.println("没有盐，不能做饭...");
    
43.                         System.out.println("等待买盐....");
    
44.                         try {
    
45.                                 this.notify();
    
46.                                 Thread.sleep(1000 * 3 * 60);
    
47.                                 this.wait();
    
48.                         } catch (InterruptedException e) {
    
49.                                 e.printStackTrace();
    
50.                         }
    
51.                 }
    
52.                 // 能做饭了。做完之后，把变量设置回去。
    
53.                 System.out.println("妈妈正在做饭。。。");
    
54.                 canCook = false;
    
55.         }
    
56. 
    
57.         /**
    
58.          * 儿子买盐的方法
    
59.          */
    
60.         public synchronized void buySalt() {
    
61.                 // 如果能做饭，儿子就休息
    
62.                 if (canCook) {
    
63.                         try {
    
64.                                 this.wait();
    
65.                         } catch (InterruptedException e) {
    
66.                                 e.printStackTrace();
    
67.                         }
    
68.                 }
    
69.                 // 如果没有盐，儿子去买盐并唤醒妈妈，把能做饭设置true
    
70.                 System.out.println("儿子去买盐了，");
    
71.                 canCook = true;
    
72.                 this.notify();
    
73.         }
    
74. }

复制代码

已经解决了，发一样的帖子是为了让更多的人看到给帮忙解决，这个是我自己粗心，多了一对{}；已经改过来了，多谢下面两位，我会参考你们的编程思路的！