Java 多线程

一：多线程基础知识

1.并行、串行、并发

• 并行：指两个或多个事件在同一时刻发生（同时发生）
• 串行: 指两个或者多个事件时间有顺序的完成，一个事件完成再完成另外一个事件
• 并发：指两个或多个事件在同一时间段内发生（交替执行）
  

2.进程与线程

• 进程：指内存中运行的应用程序，每一个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程是程序的一次执行过程，是系统运行程序的基本单元，系统运行一个程序即是一个进程从创建、运行到消亡的过程

• 线程：线程是进程中的一个 执行单元，负责当前进程中程序的执行，一个进程中至少有多个线程。一个由多线程的应用程序称为多线程程序。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

3.线程调度

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

我们可以在任务管理器中查看并改变我们电脑中的进程优先级

4.主线程

   主线程：执行主（main）方法的线程
       JVM执行main方法，main方法会进入到栈内存
       JVM会找到操作系统开辟一条main方法通向cpu的执行路径
       cpu就可以通过这个路径来执行main方法
       这个路径就叫做：主（main）线程
       
  Java中单线程程序的执行：
   单线程程序：java程序中只有一个线程
   执行中main方法开始，从上到下依次执行

演示：

//Person类
public class Person {
    private String name;

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

    public String getName() {
        return name;
    }

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

    public Person() {
    }

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

//Demo01MainThread测试程序
public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("小强");
        p1.run();

        System.out.println(0/0);        //Exception in thread "main" java.lang.ArithmeticException: / by zero
        Person p2 = new Person("旺财");
        p2.run();
    }
}

通过结果我们发现会程序会抛出异常： //Exception in thread “main” java.lang.ArithmeticException: / by zero
显示主线程（main Thread）存在异常

二：创建线程类

Java使用java.lang.Thread类表示线程，所有的线程都必须是Thread类或其子类的实例，每个线程 的作用是完成一定的任务，实际上就是执行一段程序流，即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。
JDK_API中线程和Thread的描述：

并且指出创建新执行线程有两种方式：
其一：

另一：

并且：每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

（一）：通过继承Thread类来创建并启动多线程

创建多线程的第一种方法：创建Thread类的子类

步骤：

1. 创建一个Thread类的子类
2. 在Thread类的子类中重写Thread类中的run方法，设置线程执行任务（开启线程要做什么）
3. 创建Thread类的子类对象
4. 调用Thread类中的方法start方法，开启新的线程，执行run方法。

public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程，执行其 run 方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

 注意：
 java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一优先级，随机选择一个执行

演示：

//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);
          }
     }
}

public class Demo02Thread {
    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);
        }
    }
}

结果：两个进程抢占式执行：

（二）：Thread类中的一些方法

构造方法：

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

常用方法：

• static Thread currentThread() 返回对当前正在执行的线程对象的引用。
• String getName() 返回该线程的名称。
• void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
• void setName(String name) 改变线程名称，使之与参数 name 相同。
• static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

获取线程的名称：

获取线程的名称：
    1.使用Thread类中的方法getName();
             String getName() 返回该线程的名称。
    2.可以先使用Thread类中的方法先获取到当前正在执行的线程，再使用多线程中的方法getName()获取线程的名称
             static Thread CurrentThread()   返回对正在执行的线程对象的引用。

演示：

/*
*   获取线程的名称：
*       1.使用Thread类中的方法getName();
*           String getName() 返回该线程的名称。
*       2.可以先使用Thread类中的方法先获取到当前正在执行的线程，再使用多线程中的方法getName()获取线程的名称
*               static Thread CurrentThread()   返回对正在执行的线程对象的引用。
*   设置线程的名称：
*       1.使用Thread类中的方法setName(名字)
*               void setName(String n)
* */
//1.定义一个Thread类的子类
public class MyThread02 extends Thread{
    //重写Thread类中的run方法，设置线程任务
    @Override
    public void run() {
//        //获取线程名称
//        String name = getName();
//        System.out.println(name);

        //获取线程名称
        Thread t = Thread.currentThread();
        System.out.println(t);
        System.out.println(t.getName());

        //获取线程名称：
        //链式编程：
//        System.out.println(Thread.currentThread().getName());
    }
}

/*
*   线程的名称：
*       主线程：main
*       新线程：Thread-0,Thread-1,Thread-2……
* */
public class Demo03GetThreadName {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread02 mt02 = new MyThread02();
        //调用start方法，开启新线程，执行run方法
        mt02.start();
		
		//更简化的使用，匿名对象的使用
        new MyThread02().start();
        new MyThread02().start();
    }
}

设置线程的名字：

   设置线程的名字步骤：
       1.使用Thread类中的方法setName(名字)
           void setName(String name) 改变线程的名字，使之与参数name相同
       2.创建一个带参数的构造方法，参数传递线程的名称；调用父类带参数的构造方法，让父类（Thread）给子线程起一个名字
           Thread(String name) 分配新的Thread对象

演示：

public class MyThread extends Thread{
    public MyThread(){}
   //2.创建一个带参数的构造方法，参数传递线程的名称；调用父类带参数的构造方法，让父类（Thread）给子线程起一个名字
    public MyThread(String name){
        super(name);
    }

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

public class Demo01SetThreadName {
    public static void main(String[] args) {
        //开启多线程
        MyThread mt = new MyThread();
        //1.使用Thread类中的方法setName(名字)
        mt.setName("小强");
        mt.start();

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

Tread类静态方法sleep
sleep方法实现秒表案例：

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

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

（三）：实现Runnable接口来创建并启动多线程

   创建多线程的第二种方式：实现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方法

演示：

//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);
        }
    }
}

public class Demo01Runnable {
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
//        Thread t = new Thread(run);
        //增强程序的扩展性，设置线程任务与开启新线程进行了分离
        Thread t = new Thread(new RunnableImpl2());     //打印HelloWorld
        //5.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

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

//1.创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable {
    //2.在实现类中重写Runnable接口的run方法。设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("Hello World");
        }
    }
}

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

(四)：匿名内部类方法实现线程的创建

解析：

• 匿名：没有对象名
• 内部类：写在其他类内部的类

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

public class InnerClassThread {
    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()+"-->"+"程序猿");
                }
            }
        }.start();

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

三：线程安全问题

卖电影票案例

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

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

    }
}

/*
*   模拟卖票案例：
*   创建3个线程，同时开启，对共享的票进行出售
* */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        //主意：这里创建一个Runnable的实现类，并将其传到Thread的构造方法中去，可以保证一共有100张票,以达到票源共享
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //开启多线程 ：
        t0.start();
        t1.start();
        t2.start();
    }
}

这里我们通过观察结果发现出现卖重复票（100号票等）或则不合理票的问题（-1号票）


这是由于多线程访问了共享的数据，会产生线程安全问题
下面我们介绍用同步代码块来解决线程安全问题：

四：线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题：Java中提供了同步机制（synchronized）来解决
为了保证每一进程都能正常执行原子操作，Java中引入了线程同步机制
有以下三种方法完成同步操作：
1 .同步代码块
2 .同步方法
3 .锁机制

（一）：同步代码块

解决线程安全问题的第一种方案：使用同步代码块

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

   格式：
       synchronized(锁对象){      //这个锁对象叫同步锁，也叫对象锁，也叫对象监视器
           可能会出现线程安全的代码（访问了共享数据的代码）
       }

注意：

1. 同步代码块中的锁对象，可以使用任意的对象
2. 但是必须保证多个线程使用的是同一个锁对象
3. 锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行

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

*   同步技术的原理：
*       3个进程一起抢夺cpu的执行权，谁抢到了谁执行run方法进行卖票
*           t0抢到了cpu的执行权，执行run方法，遇到 synchronized代码块这时t0会检查synchronized代码块是否有锁对象，发现有，就会获取到锁对象，进入到同步中
*           t1抢到了cpu的执行权，执行run方法，遇到synchronized代码块，这时t1会检查synchronized代码块是否有锁对象，发现没有，t1就会进入阻塞状态，会一直等待
*           t0线程执行完同步中的代码，会把锁对象还给同步代码块，t1才能获取锁对象锁对象进入到同步中执行
*        总结：
*             同步中的线程，没有执行完毕不会释放锁，同步外的进程没有锁进不去同步
*       同步保证了只能有一个线程在同步中执行共享数据
*       保证了安全，但是程序会频繁的判断锁，获取锁，释放锁，程序的效率会降低

演示：

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

    //创建一个锁对象（在run方法外边进行创建）
    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 Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        //主意：这里创建一个Runnable的实现类，并将其传到Thread的构造方法中去，可以保证一共有100张票,以达到票源共享
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //开启多线程 ：
        t0.start();
        t1.start();
        t2.start();
    }
}

（二）：同步方法

解决线程安全问题的第二种方案：使用同步方法

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

使用步骤：

• 1.把访问了共享数据的代码抽取出来，放到一个方法中
• 2.在方法上添加synchronized修饰符

格式：

  格式：
      修饰符 synchronized 返回值类型 方法名（参数列表）{
              可能出现线程安全问题的代码（访问了共享数据的代码）
      }

同步方法中的同步锁：

• 对于非static方法，同步锁就是this
• 对于static方法，我们使用当前方法所在类的字节码对象（类型.class）

演示：

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();
            }
            //票存在，卖票ticket--
            System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
            ticket--;
        }
    }
    //当payTicket声明为static后，我们要将ticket也声明为static才能使用（静态方法访问静态数据）
    /*
    *   静态的同步方法：
    *   锁对象不能是this,因为this是创建对象后产生的，静态方法先与对象产生
    *   静态方法的锁对象是本类的class属性-->class文件对象：RunnableImpl.class
    * */
}

/*
*   模拟卖票案例：
*   创建3个线程，同时开启，对共享的票进行出售
* */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        System.out.println("run:"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        //主意：这里创建一个Runnable的实现类，并将其传到Thread的构造方法中去，可以保证一共有100张票,以达到票源共享
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //开启多线程 ：
        t0.start();
        t1.start();
        t2.start();
    }
}

（三）：Lock锁

解决线程安全问题的第三种方案：使用Lock锁(java.util.concurrent.Locks.Lock接口)
java.util.concurrent.Locks.ReentrantLock implements Lock接口

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作

• void lock() 获取锁
• void unlock() 释放锁

   使用步骤：
       1.在成员位置创建一个ReentrantLock对象
       2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
       3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁

演示：

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

/*
 *   卖票案例出现了线程安全问题
 *   卖出了不存在的票和重复的票
 *
 *   解决线程安全问题的第三种方案：使用Lock锁
 *   java.util.concurrent.Locks.Lock接口
 *   Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作
 *       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);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，卖票ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
            //3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
            l.unlock();
        }*/

    //JDK文档总的更好的一种写法：tryLock
    //将unLock()放到finally代码块中
    @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(); //无论程序是否异常，都会把锁释放掉
                }
            }
        }
    }
}

/*
*   模拟卖票案例：
*   创建3个线程，同时开启，对共享的票进行出售
* */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        //主意：这里创建一个Runnable的实现类，并将其传到Thread的构造方法中去，可以保证一共有100张票,以达到票源共享
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //开启多线程 ：
        t0.start();
        t1.start();
        t2.start();
    }
}

五：等待与唤醒

进入到TimeWaiting(计时等待)有两种方式：

• 使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
• 使用wait(long m)方法，wait方法如果在毫秒值借结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

唤醒的方法：

• void notify() 唤醒在此对象监视器上等待的单个线程
• void notifyAll() 唤醒在此对象监视器上等待的所有线程

案例一：等待与唤醒之线程通信一

/*
*   等待唤醒案例：线程之间的通信
*       创建一个顾客线程（消费者）:告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
*       创建一个老板进程（生产者）：花了5秒做包子，做好包子后，调用notify方法，唤醒顾客吃包子
*
*   注意：
*       顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个正在执行
*       同步使用的锁对象才能调用wait和notify方法
*
*   Object类中的方法：
*      void wait()
*           在其他线程调用此对象的notify()方法，或notifyAll()方法前，导致当前线程等待
*      void notify()
*           唤醒在此对象监视器上等待的单个线程
*           会继续执行wait方法之后的代码
*
*   wait方法和notify()/notifyAll()方法需要注意的细节：
*   注意：
*       1.wait方法和notify方法必须由同一个锁对象调用，因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程
*       2.wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意的对象，而任意对象的所属类都是继承了Object类的
*       3.wait方法与notify方法必须同步代码块或者是同步函数中使用。因为：必须要通过锁对象，调用这两个方法
* */
public class Demo01WaitAndNotify {
    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(); //等待，直到包子做好，老板来唤醒（notify）
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，开吃");
                        System.out.println("======================");
                    }
                }
            }
        }.start();

        //创建一个老板线程（生产者）
        new Thread(){
            @Override
            public void run() {
                //一直等着卖包子
                while(true){
                    //花5秒做包子
                    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唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
*
*   唤醒的方法：
*       void notify()     唤醒在此对象监视器上等待的单个线程
*       void notifyAll()  唤醒在此对象监视器上等待的所有线程
* */
public class Demo02WaitAndNotify {
    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();
                        } 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();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，顾客2开吃");
                        System.out.println("======================");
                    }
                }
            }
        }.start();

        //创建一个老板线程（生产者）
        new Thread(){
            @Override
            public void run() {
                //一直等着卖包子
                while(true){
                    //花5秒做包子
                    try {
                        Thread.sleep(5000); //花5秒钟做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //保证保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("老板花5秒钟之后做好包子，告知顾客，可以吃包子了");
                        //做好包子之后，调用notify方法，唤醒顾客吃包子
//                        obj.notify();     //如果有多个等待线程，随机唤醒一个
                        obj.notifyAll();    //唤醒所有等待的进程
                    }
                }
            }
        }.start();
    }
}