多线程等待问题

古银平

本帖最后由李大伟于 2012-11-7 23:14 编辑

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

思考线程问题
* 1 创建两个线程妈妈线程和儿子线程，
* 2 妈妈线程先做饭，儿子线程sleep，后因没有盐，妈妈线程sleep 3分钟 ,儿子线程去买盐
* 3 儿子线程买盐回来sleep,妈妈线程做饭
* 但是run方法中一个做饭，一个买盐不会做所以……

求各位达人给讲解下谢谢！！！

谢谢各位

奋斗的青春 · 奋斗的青春

本帖最后由吴愿涛于 2012-11-5 23:54 编辑

LZ提到的好像和我之前做的测试题一样哦。
package com.itheima;

public class Test10 {

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

         static class Mother extends Thread{
            /** 盐的用量 */
            final int SaltUseage = 40;
            volatile boolean cooking = true;
            Home home;
            public void run(){
                  try {
                     while(cooking){
                        Salt salt = home.salt;
                        if(salt.value<SaltUseage){
                              home.son.buySalt();
                              waiting();
                        }
                        System.out.println("[妈妈]盐  ==>> 当前量："+salt.value+" 用去量:"+SaltUseage+" 剩余量："+(salt.value-SaltUseage));
                        salt.value -= SaltUseage;
                        otherThings();
                     }
                  } catch (Exception e) {
                     cooking = false;
                  }
            }
            private void otherThings() {
                  try {
                     sleep(1000);
                  } catch (Exception e) {
                     cooking = false;
                  }
            }
            private synchronized void waiting() throws InterruptedException {
                  System.out.println("[妈妈]盐  ==>> 当前量："+home.salt.value+"  等待儿子去买盐。");
                  home.mother.wait();
            }
            private synchronized void notice(){
                  home.mother.notify();
            }
         }
         static class Son extends Thread{
            /** 盐的购买量 */
            final int SaltPurchases = 60;
            volatile boolean free = true;
            Home home;
            public void run(){
                  try {
                     while(free){
                        waiting();
                        sleep(2000);
                        System.out.println("[儿子]盐  ==>> 当前量："+home.salt.value+" 购买量:"+SaltPurchases+" 剩余量："+(home.salt.value+SaltPurchases));
                        home.salt.value += SaltPurchases;
                        notice();
                     }
                  } catch (Exception e) {
                     free = false;
                  }
            }
            public synchronized void buySalt(){
                  notify();
            }
            private void notice() {
                  System.out.println("[儿子]盐  ==>> 当前量："+home.salt.value+" 告知妈妈盐已买到。");
                  home.mother.notice();
            }
            private synchronized void waiting() throws InterruptedException {
                  System.out.println("[儿子]盐  ==>> 当前量："+home.salt.value+" 等待下次购买。");
                  wait();
            }
         }
         static class Salt{
            int value = 90;
         }
         static class Home{
            Mother mother = new Mother();
            Son son = new Son();
            Salt salt = new Salt();
            public Home(){
                  mother.home = this;
                  son.home = this;
            }
            public void startCooking(){
                  mother.start();
                  son.start();
            }
            public void stopCooking(){
                  mother.cooking=false;
                  son.free=false;
                  mother.interrupt();
                  son.interrupt();
            }
         }

         /**
         * 测试用例
         */
         public static void main(String[] args) throws Exception {
            Home home = new Home();
            home.startCooking();
            Thread.sleep(15000);
            home.stopCooking();
         }

      }

罗宝 · 罗宝

只需要创建一个妈妈线程就行了，用妈妈实例来调用儿子对象买盐的方法，让妈妈这个线程休眠3分钟后，再用妈妈实例调用儿子对象盐买回来后说话的方法，然后打印妈妈继续做饭，就行了！

王振 · 王振

public class ThreadTest {
public static void main(String[] args) {
final Object obj = new Object(); //这里创建一个对象，作为锁。
new Thread(new Runnable() {
public void run() {
System.out.println("妈妈开始做饭...");
//这里让该线程停顿3秒钟，模拟正在做饭。
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("妈妈发现没有盐，让儿子去买，等待中...");
synchronized(obj) {
//发现没有盐之后，唤醒另一线程。
obj.notify();
//当前线程停止。等待唤醒。
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子将盐买回，妈妈继续做饭...");
}
}
}).start();
new Thread(new Runnable() {
public void run() {
synchronized(obj) {
//该线程一经启动就等待另一线程唤醒。
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子去买盐...");
//sleep3秒钟，模拟买盐过程。
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子将盐买回来，线程结束...");
//买完盐后唤醒另一线程。
obj.notify();
}
}
}).start();
}
}

复制代码

看看是不是这个意思。

葛旭东 · 葛旭东

本帖最后由葛旭东于 2012-11-6 01:44 编辑

前面几位仁兄为什么要把这么简单的问题复杂化呢？？？可以不需要同步函数和同步代码块的啊！！

这是我的代码：

class Mother implements Runnable{
public void run(){
System.out.println("妈妈在做饭...");
System.out.println("发现没有盐了，让儿子去买盐。等待中...");
//开启son线程
Thread son = new Thread(new Son());
son.start();
//加入son线程
try{son.join();}
catch(InterruptedException e)
{
throw new RuntimeException("妈妈做饭出问题了");
}
System.out.println("可以继续做饭了！！！");
}
}
class Son implements Runnable{
public void run() {
System.out.println("儿子出门去买盐了...");
for(int x=1;x<=3;x++){
try{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
throw new RuntimeException("儿子买盐出问题啦！");
}
System.out.println("过去了"+x+"分钟......");
}
System.out.println("买盐回来了！");
}
}
public class test10 {
public static void main(String[] args) {
//开启Mother线程
new Thread(new Mother()).start();
}
}

复制代码

帐号		自动登录	找回密码
密码			加入黑马

多线程等待问题

评分

4 个回复

评分

评分

评分