模拟做饭系统（java+线程中的join方法）

（一）项目框架分析

妈妈要去做饭，发现没有酱油，让儿子去买酱油，然后回来做饭。

根据面向对象的思想，有两个对象，妈妈和儿子

主要有两个方法：

（一）没有线程控制（即儿子没有买酱油回来妈妈就做好饭了）+（没有调用jion方法）

（二）有线程控制（妈妈进程和儿子进程又先后影响）+（调用jion方法）

项目的结构图：

（二）没有进程控制mintak

Son.java主要是模拟儿子的行动，儿子买酱油的行动（与有进程控制的源程序相同）

代码如下：

public class Son implements Runnable {
    public void run(){
        System.out.println("儿子出门去买酱油");
        System.out.println("儿子买东西来回需要五分钟");

        //买酱油过程
        try{
            for(int i=1;i<=5;i++){
                Thread.sleep(1000);
                System.out.print(i+"分钟");
            }
        }catch (InterruptedException ie){
            System.out.println("\n儿子买酱油回来了");
        }
    }
}

Mother.java主要是模拟妈妈的行为，

主要代码如下

package com.cjg.normal;

import com.cjg.mistak.Son;

public class Mother implements Runnable {
    public void run(){
        //输出相应的信息，即妈妈发现没有酱油，叫儿子去买酱油回来
        System.out.println("妈妈准备煮饭");
        System.out.println("妈妈发现酱油用完了");
        System.out.println("妈妈叫儿子去买酱油");
        Thread son =new Thread(new Son());
        son.start();
        System.out.println("妈妈等待儿子买酱油回来");
        try{
            //当两个线程合并成功后，妈妈线程的执行必须等儿子线程执行完毕之后
            son.join();
        }catch (InterruptedException ie){
            //输出相应信息
            System.err.println("发生异常！");
            System.err.println("妈妈中断煮饭！");
            System.exit(1);
        }
        //儿子买酱油回家，妈妈开始做饭
        System.out.println("妈妈开始煮饭");
        System.out.println("妈妈煮好饭了");
    }

}

Cooking.java是测试妈妈和儿子的类是否实现了做饭

import com.cjg.mistak.Mother;

public class Cooking {
    public static void main(String argv[]){
        Thread mother = new Thread(new Mother());
    }
}

（三）有进程控制的

主要是Mother.java类中的内容有不同，

Mother.java类的具体代码：

package com.cjg.normal;

import com.cjg.mistak.Son;

public class Mother implements Runnable {
    public void run(){
        //输出相应的信息，即妈妈发现没有酱油，叫儿子去买酱油回来
        System.out.println("妈妈准备煮饭");
        System.out.println("妈妈发现酱油用完了");
        System.out.println("妈妈叫儿子去买酱油");
        Thread son =new Thread(new Son());
        son.start();
        System.out.println("妈妈等待儿子买酱油回来");
        try{
            //当两个线程合并成功后，妈妈线程的执行必须等儿子线程执行完毕之后
            son.join();
        }catch (InterruptedException ie){
            //输出相应信息
            System.err.println("发生异常！");
            System.err.println("妈妈中断煮饭！");
            System.exit(1);
        }
        //儿子买酱油回家，妈妈开始做饭
        System.out.println("妈妈开始煮饭");
        System.out.println("妈妈煮好饭了");
    }

}

（四）线程的状态

（4-1）基本状态

线程也有生命周期，在自己的生命周期会有5种状态，new（创建）、runnable（等待运行）、running（运行）、blocked（暂停）和dead（结束）。

它们的关系如图

当产生Thread类对象时，该对象就会处于new状态，调用start()方法后就会进入runnable状态。如果CPU调用该线程时，就会从runnable状态进入running状态，运行线程中run()方法中的代码，具体过程如下图：

（4-2）线程的暂停状态

对应线程对象，如果想实现让其暂时停止，但是恢复运行后又不产生一个新的线程对象时，就需要学习如何使线程处于暂停状态。我们可以通过一下4种方式来实现该功能：

　　1.sleep()方法

　　sleep这个单词的英文意思是睡觉，主要用来实现让thread对象睡觉，不过在睡觉时设置了闹钟，时间一到就会恢复运行，该方法的使用方法为：

thread.sleep(long millis)

millis表示的是睡眠时间，这个时间的单位是千分之一秒，如果想睡1s的话，则需要传入的是1000

　　当一个thread类对象睡醒之后，不是立刻进入running状态，而是先进入runnable状态。

　　2.yield()方法

当CPU正调用一个线程运行时，如果该线程睡眠一段时间后才被执行，就需要调用sleep()方法；如果该线程不想这时候运行，可以调用yield()方法。

对于sleep（）方法，线程在指定的时间里肯定不会由running状态转换到runnable状态；

对于yield（）方法，线程可能马上由running状态转换到runnable状态。

使用的基本方法为：

thread.yield()

　　3.join()方法

当处于runnable状态的线程为好几个线程时，如果线程1需要等待线程2完成某件事后，才能继续执行下去，这时就需要用到join()方法。

使用的基本格式如下：

Thread.join()

　　4.wait()方法和nofity()方法

wait()方法与join()方法非常类似，对于join（）方法，线程1需要等待线程2完成某件事情后才能继续进行下去，线程2完成就表示该线程运行完毕自然死亡；而对于wait()方法，只有线程2调用nofity()方法来唤醒线程1，其才能执行。

（4-3）线程的结束状态

相要结束线程有两种方式：自然消亡和强制消亡。

自然消亡：是指一个线程从其的run()方法的结尾处返回，执行结束之后自然消亡。

强制消亡：是指用Thread类中的stop()方法强制线程结束，不建议使用。