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

朴灿烈づ我的快乐病毒、 2023-06-12 09:12 14阅读 0赞

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() + "创建了一个新的线程");
        }
    }