JAVA-多线程

并发与并行:

进程概念：


线程：

线程调度：

主线程：

package dl.java.day21;

public class Person {
    private  String name;

    public void run(){
        //定义循环，执行20次
        for (int i = 0; i < 3; i++) {
            System.out.println(name+">"+i);
        }
    }
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package dl.java.day21;
/*
    主线程：执行主(main)方法的线程
    单线程程序：java程序中只有一个程序
    执行main方法开始，从上到下依次执行
 */
public class MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("张三");
        p1.run();

        Person p2 = new Person("李四");
        p2.run();
    }
}

创建多线程程序：第一种方式

package dl.java.day21.Demo01;
//1.创建一个Thread的子类
public class MyThread extends Thread{
    //2.在Thread的子类中重写Thread类中run方法，设置线程任务(开启线程要做什么)

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("run"+i);
        }
    }
}

package dl.java.day21.Demo01;
/*
    创建多线程程序的第一种方式：创建Thread的子类
    java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

    实现步骤：
        1.创建一个Thread的子类
        2.在Thread的子类中重写Thread类中run方法，设置线程任务(开启线程要做什么)
        3.创建Thread类的子类对象
        4.调用Thread类中的方法start方法，开启新的线程，执行run方法
            void start() 使该线程开始执行：Java虚拟机调用该线程的run方法
            结果是两个线程并发的运行：当前线程(main线程) 和另一个线程(创建的新线程，执行其run方法)
            多次启动一个线程是非法的，特别是当线程已经结束执行后，不能重新启动
    Java程序属于抢占式调度，哪个线程的优先级高，哪个线程先执行；同一个优先级，随机选择一个执行
 */
public class Demo01Thread {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread mt = new MyThread();
        //4.调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main"+i);
        }
    }
}

多线程原理：随机性打印结果

多线程原理_多线程内存图解

获取线程名称：

package dl.java.day21.Demo02;
/*
    获取线程的名称：
        1.使用Thread类中的方法getName()
            String getName() 返回该线程的名称
        2.先获取到正在执行的线程，使用方法getName()获取线程的名称
            static Thread currentThread() 返回对当前正在执行线程对象的引用
 */
//定义一个Thread 类的子类
public class MyThread extends Thread{
    //重写Thread 类中的run方法,设置线程任务

    @Override
    public void run() {
        //获取线程名称
        //String name = getName();
        //System.out.println(name);

        //Thread t = Thread.currentThread();
        //System.out.println(t);//Thread[Thread-0,5,main]
        ///String name = t.getName();
        //System.out.println(name);

        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

package dl.java.day21.Demo02;
/*
    线程的名称：
        主线程：main
        新线程：Thread-0
 */
public class GetThreadName {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread mt = new MyThread();
        //调用start，开启新线程，执行run方法
        mt.start();

        new MyThread().start();
        new MyThread().start();

        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

Thread类的常用方法：设置线程名称

package dl.java.day21.Demo03;
/*
    设置线程名称：(了解)
        1.使用Thread类中的方法setName(名字)
            void setName(String name) 改变线程名称，使之与参数name相同
        2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传给父类，
        让父类(Thread)给子线程起名
            Thread(String name) 分配新的 Thread 对象
 */
public class MyThread extends Thread{

    public MyThread(){
    }

    public MyThread(String name){
        super(name);//调用父类的带参构造方法，把线程名称传给父类，
    }

    @Override
    public void run() {
        //获取线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

package dl.java.day21.Demo03;

public class SetThreadName {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.setName("一号");
        mt.start();

        //开启多线程
        new MyThread("二号").start();
    }
}

Thread类的常用方法：sleep

package dl.java.day21.Demo03;
/*
    public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(暂停执行)
    毫秒数结束之后，线程继续执行
 */
public class Sleep {
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 0; i <= 60; i++) {
            System.out.println(i);

            //使用Thread类中的方法sleep让程序睡眠一秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

创建线程方式二_实现：

package dl.java.day21.Demo04;
//1.创建一个Runnable 接口的实现类
public class RunnableImpl implements Runnable {
    //2.在实现类中重写Runnable 接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+">"+i);
        }
    }
}

package dl.java.day21.Demo04;
/*
创建多线程程序的第二种方式：实现Runnable 接口
java.long.Runnable
    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个称为run 的无参数方法
java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的Thread对象
    Thread(Runnable target,String name) 分配新的Thread对象

    实现步骤：
        1.创建一个Runnable 接口的实现类
        2.在实现类中重写Runnable 接口的run方法，设置线程任务
        3.创建一个Runnable 接口的实现类对象
        4.创建Thread类对象，构造方法中传递Runnable 接口的实现类对象
        5.调用Thread类中的start方法，开启新的线程，执行run方法
 */
public class Demo04Runnable {
    public static void main(String[] args) {
        //3.创建一个Runnable 接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable 接口的实现类对象
        Thread t = new Thread(run);
        //5.调用Thread类中的start方法，开启新的线程，执行run方法
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+">"+i);
        }
    }
}

Thread和Runnable的区别：

/*
	实现Runnable接口创建多线程程序的好处：
        1.避免单继承的局限性
            一个类只能继承一个类，类继承了Thread就不能继承其他类
            实现了Runnable接口，还可以继承其他的类，实现其他的接口
        2.增强的了程序的扩展性，降低了程序的耦合性(解耦)
            实现Runnable接口的方式，把设置线程任务和开启线程进行了分离(解耦)
            实现类中重写了run方法：用来设置线程任务
            创建了Thread类对象，调用start方法：用来开启新线程
*/

匿名内部类实现线程的创建：

package dl.java.day21.Demo05;
/*
    匿名内部类方式实现线程的创建
    匿名：没有名字
    内部类：写在其他类内部的类

    匿名内部类的作用：简化代码
        把子类继承父类，重写父类的方法创建子类对象合成一步完成
        把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成
    匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

    格式：
        new 父类/接口(){
            重写父类/接口类中的方法
        };
 */
public class Demo05InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+">"+i);
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl(); //多态
        Runnable r = new Runnable(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+">"+"接口");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+">"+"简化");
                }
            }
        }).start();
    }
}

线程安全：

线程安全问题的代码实现：

package dl.java.day21.Demo06;
/*
    实现卖票案例
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票重复执行
        while (true) {
            //先判断票是否存在
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠一下
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在，卖
                System.out.println(Thread.currentThread().getName()+"还剩 "+ticket+" 张票");
                ticket--;
            }
        }
    }
}

package dl.java.day21.Demo06;
/*
    模拟卖票案例
    创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable 接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法，开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程安全产生原理：

线程同步：

package dl.java.day21.Demo07;
/*
    实现卖票案例 出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的第一种方案：使用同步代码块
    格式：
        synchronized (锁对象){
            可能会出现线程安全问题的代码(访问了共享数据的代码)
        }
    注意:
        1.通过代码块中的锁对象，可以使用任意的对象
        2.但是必须保证多个线程使用的锁对象是同一个
        3.锁对象的作用：
            把同步代码块锁住，只让一个线程在同步代码块中执行
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票重复执行
        while (true) {
           //同步代码块
            synchronized (obj){
                //先判断票是否存在
                if (ticket>0){
                    //提高安全问题出现的概率，让程序睡眠一下
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //票存在，卖
                    System.out.println(Thread.currentThread().getName()+"卖第 "+ticket+" 张票");
                    ticket--;
                }
            }
        }
    }
}

package dl.java.day21.Demo07;

/*
    模拟卖票案例
    创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable 接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法，开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

同步技术的原理：

解决线程安全方法_同步方法：

package dl.java.day21.Demo08;
/*
    卖票案例出现了线程安全问题：
    卖出不存在和重复的票

    解决线程安全的第二种方法：同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放在一个方法里
        2.在方法上添加synchronized 修饰符

    格式：
        修饰符 synchronized 返回值类型 方法名 (参数列表){
            访问了共享数据的代码
        }
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //设置线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:"+this);
        //使用死循环，让卖票重复执行
        while (true) {
            //先判断票是否存在
            payTicket();
        }
    }

    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁？ 就是实现类对象 new RunnableImpl()
        也就是this
     */
    public synchronized  void payTicket (){
        if (ticket>0){
            //提高安全问题出现的概率，让程序睡眠一下
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //票存在，卖
            System.out.println(Thread.currentThread().getName()+"还剩 "+ticket+" 张票");
            ticket--;
        }
    }
}

package dl.java.day21.Demo08;

/*
    模拟卖票案例
    创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable 接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法，开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

静态同步(了解)：

package dl.java.day21.Demo08;
/*
    卖票案例出现了线程安全问题：
    卖出不存在和重复的票

    解决线程安全的第二种方法：同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放在一个方法里
        2.在方法上添加synchronized 修饰符

    格式：
        修饰符 synchronized 返回值类型 方法名 (参数列表){
            访问了共享数据的代码
        }
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;

    //设置线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:"+this);
        //使用死循环，让卖票重复执行
        while (true) {
            //先判断票是否存在
            payTicketStatic();
        }
    }
/*
    静态的同步方法：
        锁对象是谁？  不是this
                     this是创建对象之后产生的，静态方法优先于对象
        静态方法的锁对象是本类的class属性-->class文件对象（反射）
 */
    public static synchronized  void payTicketStatic (){
        synchronized (RunnableImpl.class){
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠一下
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，卖
                System.out.println(Thread.currentThread().getName()+"还剩 "+ticket+" 张票");
                ticket--;
            }
        }
    }
    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁？ 就是实现类对象 new RunnableImpl()
        也就是this
     */
}


package dl.java.day21.Demo08;
/*
    模拟卖票案例
    创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable 接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法，开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程安全的第三种方法：lock锁

package dl.java.day21.Demo09;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
    卖票案例出现了线程安全问题：
    卖出不存在和重复的票

    解决线程安全问题的第三种：使用Lock锁
    java.util.concurrent.locks.Lock接口
    Lock 实现提供了比使用 synchronized 方法和语句可获得更广泛的锁定操作
    Lock接口中的方法：
        void lock()  获取锁
        void unlock() 释放锁
        java.util.concurrent.locks.ReentrantLock implements Lock接口
    使用步骤：
        1.在成员位置创建一个ReentrantLock对象
        2.在可能出现线程安全问题的代码前调用Lock接口中的方法lock获取锁
        3.在可能出现线程安全问题的代码后调用Lock接口中的方法unlock释放锁
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票重复执行
        while (true) {
            //2.在可能出现线程安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            //先判断票是否存在
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠一下
                try {
                    Thread.sleep(10);
                    //票存在，卖
                    System.out.println(Thread.currentThread().getName()+"还剩 "+ticket+" 张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3.在可能出现线程安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock();//无论程序是否出现异常，都会把锁释放
                }
            }
        }
    }

    /*//设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票重复执行
        while (true) {
            //2.在可能出现线程安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            //先判断票是否存在
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠一下
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在，卖
                System.out.println(Thread.currentThread().getName()+"还剩 "+ticket+" 张票");
                ticket--;
            }
            //3.在可能出现线程安全问题的代码后调用Lock接口中的方法unlock释放锁
            l.unlock();
        }
    }*/
}

package dl.java.day21.Demo09;

/*
    模拟卖票案例
    创建三个线程，同时开启，对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable 接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法，开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程状态：
概述：

等待唤醒分析:Timed Waiting 计时等待

BLOCKED 锁阻塞

Waiting 无限等待:


代码：

package dl.java.day21.Demo10;
/*
    等待唤醒案例：线程之间的通信
        创建一个顾客线程：告知老板要的包子的种类和数量，调用wait()方法，进入WAITING状态(无限等待状态)
        创建一个老板线程：花了5秒做好，之后调用notify()方法，唤醒顾客吃包子
    注意：
        顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
        同步使用的锁对象必须保证唯一
        只有锁对象才能调用wait和notify方法
        void wait() 在其他线程调用此对象 notify()方法或 notifyAll()方法前，导致当前线程等待。
        void notify() 唤醒在此对象监视器上等待的多个线程
                       会继续执行wait方法之后的代码
 */
public class WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
               while (true){
                   //保证等待和唤醒只能有一个在执行,同步技术
                   synchronized (obj){
                       System.out.println("告知老板要的包子的种类和数量");
                       //调用wait()方法，进入WAITING状态(无限等待状态)
                       try {
                           obj.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       //唤醒之后执行的
                       System.out.println("上桌，开吃");
                       System.out.println("------------------------");
                   }
               }
            }
        }.start();

        //创建一个老板线程
        new Thread(){
            @Override
            public void run() {
                //一直做包子
               while (true){
                   try {
                       Thread.sleep(5000);//花了5秒做好
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   //保证等待和唤醒只能有一个在执行，同步技术
                   synchronized (obj){
                       System.out.println("经过5秒钟，包子好了，告知顾客，可以吃了");
                       //唤醒顾客吃包子
                       obj.notify();
                   }
               }
            }
        }.start();
    }
}

Object 类中wait带参方法和notify

package dl.java.day21.Demo10;
/*
    进入到TimeWaiting（计时等待）有两种方式：
    1.使用sleep(long m)方法，在毫秒值结束之后，线程唤醒进入到Runnable/Blocked状态
    2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，
        线程唤醒进入到Runnable/Blocked状态

    唤醒方法：
        void notify()  唤醒在此对象监视器上等待的单个线程
        void notifyAll() 唤醒在此对象监视器上等待的所有线程
 */
public class WaitAndNotify02 {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while (true){
                    //保证等待和唤醒只能有一个在执行,同步技术
                    synchronized (obj){
                        System.out.println("顾客1告知老板要的包子的种类和数量");
                        //调用wait()方法，进入WAITING状态(无限等待状态)
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的
                        System.out.println("顾客1上桌，开吃");
                        System.out.println("------------------------");
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while (true){
                    //保证等待和唤醒只能有一个在执行,同步技术
                    synchronized (obj){
                        System.out.println("顾客2告知老板要的包子的种类和数量");
                        //调用wait()方法，进入WAITING状态(无限等待状态)
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的
                        System.out.println("顾客2上桌，开吃");
                        System.out.println("------------------------");
                    }
                }
            }
        }.start();

        //创建一个老板线程
        new Thread(){
            @Override
            public void run() {
                //一直做包子
                while (true){
                    try {
                        Thread.sleep(5000);//花了5秒做好
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒只能有一个在执行，同步技术
                    synchronized (obj){
                        System.out.println("经过5秒钟，包子好了，告知顾客，可以吃了");
                        //唤醒顾客吃包子
                        //obj.notify();//如果有多个等待线程，随机唤醒一个
                        obj.notifyAll();//唤醒所有等待线程
                    }
                }
            }
        }.start();
    }
}

等待和唤醒机制：

整体实现：

package dl.java.day21.Demo11;
/*
    资源类：包子类、
    设置包子的属性：
        皮
        馅
        包子的状态：true  false
 */
public class BaoZi {
    //皮
    String  pi;
    //馅
    String xian;
    //包子的状态：true  false,设置初始值为false
    boolean flag = false;
}

package dl.java.day21.Demo11;
/*
    包子铺类：是一个线程类，可以继承Thread
    设置线程任务run：生产包子
    对包子的状态进行判断
    true：有包子
        调用wait()方法进入等待状态
    false：没有包子
        包子铺生产包子：两种包子交替生产
            两种状态(i%2==0)
        包子铺生产好了包子
        修改包子的状态为true有
        唤醒吃货线程，让吃货线程吃包子

    注意：
        包子铺线程和包子线程关系--->通信(互斥)
        必须使用同步技术保证两个线程只有一个在执行
        锁对象必须保证唯一，可以使用包子对象作为锁对象
        包子铺类和吃货类就需要把包子对象作为参数传递进来
            1.需要在成员位置创建一个包子变量
            2.使用带参构造方法，为这个包子变量赋值
 */
public class BaoZiPu extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;

    //2.使用带参构造方法，为这个包子变量赋值
    public BaoZiPu(BaoZi bz) {
        this.bz = bz;
    }

    //设置线程任务run：生产包子
    @Override
    public void run() {
        //定义一个变量
        int count = 0;
        //让包子铺一直生产包子
        while (true){
            //必须使用同步技术保证两个线程只有一个在执行
            synchronized (bz){
                //对包子的状态进行判断
                if (bz.flag==true){
                    //调用wait()方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒之后执行，包子铺生产包子
                //两种包子交替生产
                if (count%2==0){
                    //生产薄皮三鲜包子
                    bz.pi="薄皮";
                    bz.xian="三鲜";
                }else {
                    //生产厚皮牛肉大葱包子
                    bz.pi="厚皮";
                    bz.xian="牛肉大葱";
                }
                count++;
                System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
                //生产包子需要3秒种
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 包子铺生产好了包子
                //修改包子的状态为true有
                bz.flag=true;
                //唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺生产好了："+bz.pi+bz.xian+"包子，吃货开吃");
            }
        }
    }
}

package dl.java.day21.Demo11;
/*
    吃货类：是一个线程类，可以继承Thread
    设置线程任务run：吃包子
    对包子的状态进行判断：
        false：没有包子
        吃货调用wait()进入等待状态
        true：有包子
        吃货吃包子
        吃完包子
        修改包子的状态为false
        吃货唤醒包子铺线程，生产包子
 */
public class ChiHuo extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;

    //2.使用带参构造方法，为这个包子变量赋值
    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }

    //设置线程任务run：吃包子
    @Override
    public void run() {
        //使用死循环，让吃货一直吃包子
        while (true){
            //必须使用同步技术保证两个线程只有一个在执行
            synchronized (bz){
                //对包子的状态进行判断：
                if (bz.flag==false){
                    //吃货调用wait()进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃："+bz.pi+bz.xian+"包子");
                //吃完包子
                //修改包子的状态为false
                bz.flag=false;
                //吃货唤醒包子铺线程，生产包子
                bz.notify();
                System.out.println("吃货吃完："+bz.pi+bz.xian+"包子，包子铺快去生产");
                System.out.println("--------------------------------------------");
            }
        }
    }
}

package dl.java.day21.Demo11;
/*
测试类：
    包含main方法，程序执行入口，启动程序
    创建包子对象
    创建包子铺线程，开启，生产包子
    创建吃货线程，开启，吃包子
 */
public class Demo {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子铺线程，开启，生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}