（java总结）等待唤醒案例：线程之间的通信、线程池概述和实现

package Demo38;
/*
  注意细节：
    1、wait方法和notify方法必须有同一个锁对象调用，
    2、wait方法与notify方法属于Object类方法，锁对象可以是任意对象，
    3、wait和notify方法必须要在同步代码块或者同步函数中使用
等待唤醒案例：线程之间的通信

    创建一个顾客线程：告知老板要的包子的种类和数量，条用wait()方法，放弃cpu的执行，进入到Waiting状态(无限等待)
    创建一个老板线程：花5秒做包子，做好按包子，调用notify方法，唤醒顾客吃包子

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

 Object类中的方法
 void wait()
    在其他线程调用此对象notify()方法或notifyAll()方法前，导致当前线程等待
  void notify()
     唤醒此对象监视器上等待的单个线程
     唤醒之后会继续执行wait方法之后的代码
    */
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("告诉老板要买包子");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒之后执行的代码
                    System.out.println("包子已经做好了");
                }
            }}
        }.start();

        //创建一个老板的线程(生产者)
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒只能有一个执行，需要使用同步技术
                    synchronized (obj) {
                        System.out.println("老板五秒之后包子做好，告知顾客");
                        obj.notify();
                    }
                }
            }
        }.start();

    }
}

package Demo38;

/**
 * 进入到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告诉老板要买包子");
                    try {
                        //wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
                        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告诉老板要买包子");
                    try {
                        //wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
                        obj.wait();
                    } 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);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //保证等待和唤醒只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("老板五秒之后包子做好，告知顾客");
                    //只能唤醒一个
                    //obj.notify();
                    //唤醒所有等待的线程
                    obj.notifyAll();
                }
            }
        }
        }.start();

    }
}

package Demo39;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
线程池：JDK1.5之后提供的
java.util.concurrent.Executors: 线程的工厂类，用来生成线程池
Executors类中低的静态方法：
        static ExecutorService newFixedThreadPool(int nThreads,创建可重用固定线程的线程池)
        参数：int nThread：创建线程池中包含线程的数量
        返回值： ExecutorService接口，返回的是ExecutorService接口的实现类对象，可以使用ExecutorService接口接受(面向)

        java.util.concurrent.ExecutorService:线程接口
            用来获取线程池中获取线程，调用start方法，执行线程任务
                submit(Runnable task)提交一个Runnable任务用于执行
            关闭销毁线程池的方法
                void shutdown()
         线程池的使用步骤：
            1、使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
            2、创建一个类，实现Runnable接口，重写run方法，设置线程任务
            3、调用ExecutorService中的方法submit。传递线程任务(实现类)，开启线程，执行run方法
            4、调用ExecutorService中的shutdown销毁线程池(一般不建议执行)
 */
public class DemoThreadPool {
    public static void main(String[] args) {

        // 1、使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);

        // 3、调用ExecutorService中的方法submit。传递线程任务(实现类)，开启线程，执行run方法
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());

        es.shutdown();
        //线程池没有了，抛异常
        es.submit(new RunnableImpl());
    }
}

package Demo39;
//  2、创建一个类，实现Runnable接口，重写run方法，设置线程任务
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了一个新的线程");
    }
}