java的线程、多线程、线程安全、锁机制、Thread类

线程

多线程

我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计?

要解决上述问题，咱们得使用多进程或者多线程来解决

并发与并行

• 并发:指两个或多个事件在同一个时间段内发生
• 并行:指两个或多个事件在同一时刻发生(同时发生)。

线程与进程

• 进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位:系统运行一个程序即是一个进程从创建运行到消亡的过程。
• 线程:线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  简而言之:一个程序运行后至少有一个进程，一个进程中可以包含多个线程

进程的概念

线程的概念

线程的调度

• 分时调度
  所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
• 抢占式调度
  优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

抢占式调度详解

创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。 Java中通过继承Thread类来创建并启动多线程的步骤如下:

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
   run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程

主线程（创建多线程的第一种方式）

/*
    主线程：执行主方法(main)方法的线程

    单线程程序：java程序只有一个线程
    执行从main方法开始，从上到下依次执行

    JVM执行main方法，main方法会进入到栈内存
    JVM会找操作系统开辟一条main方法通向cpu的执行路径
    cpu就会通过这个路径来执行main方法
    而这个路径有一个名字，叫main(主)线程
 */
public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("小强");
        p1.run();
        System.out.println(0/0);//ArithmeticException: / by zero
        Person p2 = new Person("旺财");
        p2.run();
    }
}

public class Person {
    private String name;

    public void run(){
        //定义循环，执行20次
        for (int i = 0; i < 20; 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;
    }
}

/*
    创建多线程程序的第一种方式：创建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 < 20; i++) {
            System.out.println("main:" + i);
        }
    }
}

//1.创建一个Thread类的子类
public class MyThread extends Thread{
    // 2.在Thread的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run:" + i);
        }
    }
}

多线程原理

多线程的内存图解

Thread类常用方法

API中该类中定义了有关线程的一些方法，具体如下
构造方法:

• public Thread():分配一个新的线程对象
• public Thread(String name):分配一个指定名字的新的线程对象。
• public Thread(Runnable target):分配一个带有指定目标新的线程对象
• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法:

• public String getName():获取当前线程名称。
• public void start():导致此线程开始执行;Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
• public static Thread currentThread():返回对当前正在执行的线程对象的引用。

翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式，接下来讲解方式二实现的方式。

获取线程名称的两种方式

MyThread2.java

/*
    获取线程的名称：
        1.使用Thread类中的方法getName()
            String getName() 返回该线程的名称，
        2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
            static Thread currentThread() 返回对当前正在执行的线程对象的引用
 */
//定义一个Thread的子类
public class MyThread2 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-1,5,main]

        //String name = t.getName();
        //System.out.println(name);

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

Demo02GetThreadName.java

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

        new MyThread2().start();
        new MyThread2().start();

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

设置线程名称的两种方式

MyThread3.java

/*
    设置线程的名称(了解):
        1.使用Thread类中的方法setName(名字)
            void setName(String name) 改变线程名称，使之与参数 name相同。
        2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类(Thread)给子线程起一个名字
            Thread(String name) 分派心得Thread 对象。
 */
public class MyThread3 extends Thread{

    public MyThread3(){}

    public MyThread3(String name){
        super(name);//把线程名称传递给父类，让父类(Thread)给子线程起一个名字
    }

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

Demo03SetThreadName.java

public class Demo03SetThreadName {
    public static void main(String[] args) {
        //开启多线程
        MyThread3 mt = new MyThread3();
        mt.setName("小强");
        mt.start();

        //开启多线程
        new MyThread3("旺财").start();
    }
}

线程的sleep方法

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

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

创建多线程的第二种方式(Runnable)

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可
步骤如下

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的
   线程对象。
3. 调用线程对象的start()方法来启动线程

Demo05Runnable.java

/*
    创建多线程程序的第二种方法：实现Runnable接口
    java.lang.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 Demo05Runnable {
    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);
        }
    }
}

RunnableImpl.java

//.创建一个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);
        }
    }
}

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享

总结：

实现Runnable接口比继承Thread类所具有的优势

1. 适合多个相同的程序代码的线程去共享同一个资源
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 4线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类

扩充:在iava中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个VM其实在就是在操作系统中启动了一个进程。

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

/*
    匿名内部类方法实现线程的创建

    匿名：没有名字
    内部类：写在其他类内部的类

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

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

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

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

线程安全

线程安全

RunnableImpl2.java

/*
    实现卖票案例
 */
public class RunnableImpl2 implements Runnable {
    //定义一个多个线程共享的票源
    private int ticket = 100;

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

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

Demo07Ticket.java

/*
    模拟卖票案例
    创建3个线程，同时开启，对贡献的票进行出售
 */
public class Demo07Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl2 run = new RunnableImpl2();
        //创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程安全问题产生原理

线程同步

为了保证每个线程都能正常执行原子操作Java引入了线程同步机制。那么怎么去使用呢?有三种方式完成同步操作:

1. 同步代码块
2. 同步方法。
3. 锁机制。

同步代码块

• 同步代码块 ：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

格式：

synchronized(同步锁){
    需要同步操作的代码
}

同步锁：

对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁

1. 锁对象可以是任意类型。
2. 多个线程对象要使用同一把锁。

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。

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

    解决线程安全问题的一种方案：使用同步代码块
    格式：
        synchronized(锁对象){
            可能会出现线程安全问题的代码(访问了共享数据的代码)
        }

    注意：
        1.通过代码块中的锁的对象，可以使用任意的对象
        2.但是必须保证多个线程使用的锁对象是同一个
        3.锁对象作用：
            把同步代码锁住，只让一个线程在同步代码块中执行
 */
public class RunnableImpl22 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();
                    }

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

/*
    模拟卖票案例
    创建3个线程，同时开启，对贡献的票进行出售
 */
public class Demo07Ticket2 {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl22 run = new RunnableImpl22();
        //创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

同步方法

• 同步方法:使用synchronized修饰的方法，就叫做同步方法,保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式:

public synchronized void method(){}
	可能会产生线程安全问题的代码
}

同步锁是谁?
对于非static方法,同步锁就是this

​ 对于static方法我们使用当前方法所在类的字节码对象(类名.class)。

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

    解决线程安全问题的二种方案：使用同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放在一个方法中

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

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

    //设置线程任务卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行
        while(true){
            payTicket();
        }
    }
    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁？
        就是实现类对象 new RunnableImpl23
        也就是this
     */
    public /*synchronized*/ void payTicket(){
        synchronized (this) {
            //先判断票是否存在
            if (ticket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

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

/*
    模拟卖票案例
    创建3个线程，同时开启，对贡献的票进行出售
 */
public class Demo07Ticket3 {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl23 run = new RunnableImpl23();
        //创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

静态同步方法（了解）

public class RunnableImpl23 implements Runnable {
    //定义一个多个线程共享的票源
    private static int ticket = 100;

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

    //设置线程任务卖票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行
        while(true){
            payTicketStatic();
        }
    }
    /*
        静态的同步方法
        锁对象是谁？
        不能是this
        this是创建对象之后产生的，静态方法优先于对象
        静态方法的锁对象是本类的class属性-->class文件对象(反射)
     */
    public static /*synchronized*/ void payTicketStatic(){
        synchronized (RunnableImpl23.class) {
            //先判断票是否存在
            if (ticket > 0) {
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

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

public class Demo07Ticket3 {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl23 run = new RunnableImpl23();
        //创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

Lock锁(JDK1.5之后)

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作同步代码块/同步方法具有的功能Lock都有除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下:

• public void lock():加同步锁。
• public void unlock():释放同步锁。

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 RunnableImpl24 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);
                    //票存在，卖票 ticket--
                    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();
                }

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

            //3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
            l.unlock();
        }
    }*/
}

/*
    模拟卖票案例
    创建3个线程，同时开启，对贡献的票进行出售
 */
public class Demo07Ticket4Lock {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl24 run = new RunnableImpl24();
        //创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程状态

线程状态概述

线程的状态图

Timed Waiting（计时等待）

TimedWaiting在AP中的描述为:一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。

在写卖票的案例中，为了减少线程执行太快，现象不明显等问题，在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠(暂停执行)，以“减慢线程”

其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)

Timed Waiting线程状态图

BLOCKED（锁阻塞）

Blocked状态在API中的介绍为:一个正在阻塞等待一个监视器锁(锁对象)的线程处于这一状态。

学完同步机制，这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。
Blocked线程状态图

Waiting（无限等待）

Wating状态在API中介绍为:一个正在无限期等待另一个线程执行一个特别的(唤醒)动作的线程处于这一状态。

案例演示

代码实现

/*
    等待唤醒案例：线程之间的通信
        创建一个顾客线程(消费者)：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
        创建一个老板线程(生产者)：花了5秒做包子，做好包子之后，代用notify方法，唤醒顾客吃包子

    注意：
        顾客和老板线程必须使用同步代码快包裹起来，保证等待和唤醒只能一个在执行
        同步使用的锁对象必须保证唯一
        只有锁对象才能调用wait和notify方法

    Object类中的方法
    void wait()
        在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待
    void notify()
        唤醒在此对象监视器上等待的单个线程
        会继续执行wait方法之后的代码
 */
public class demo08WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while (true){
                    //保证等待和唤醒的线程只能有一个在执行
                    synchronized (obj){
                        System.out.println("告知老板要的包子的种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到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秒中之后做好包子，告知顾客，可以吃包子了！");
                        //做好包子之后，代用notify方法，唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

/*
    进入到TimeWaiting(计时等待)有两种方法
        1.使用sleep(Long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
        2.使用wait(Long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来
    唤醒的方法：
        void notify() 唤醒在此对象监控器上等待的单个线程
        void notifyAll() 唤醒在此对象监控器上等待的所有线程
 */
public class demo08WaitAndNotify2 {
    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方法，放弃cpu的执行，进入到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方法，放弃cpu的执行，进入到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秒中之后做好包子，告知顾客，可以吃包子了！");
                        //做好包子之后，代用notify方法，唤醒顾客吃包子
                        //obj.notify();//如果有多个线程等待，随机唤醒一个
                        obj.notifyAll();//唤醒所有等待的线程
                    }
                }
            }
        }.start();
    }
}