Java学习：等待唤醒机制

等待唤醒机制

线程的状态

1. NEW   至今尚未启动的线程处于这种状态
2. RUNNABLE   正在Java虚拟机中执行的线程处于这种状态
3. BLOCKED　受阻塞并等待某个监视器锁的线程处于这种状态
4. WAITING　无限期的等待另一个线程来执行某一待定操作的线程处于这种状态
5. TIMED_WAITNG　等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态
6. TERMINATED　已退出的线程处于这种状态。

• 阻塞状态：具有cpu的执行资格，等待cpu空闲时执行
• 休眠状态：放弃cpu的执行资格，cpu空闲，也不执行

等待唤醒案例分析

public static void sleep(Long millis):使用当前正在执行的线程以指定的毫秒数暂停（暂停停止执行).

• 毫秒数结束之后，线程继续执行

等待唤醒案例：线程之间的通信

• 创建一个顾客线程（消费者）：告知老板要包子的中类和数量，调用wait方法，放弃cpu的执行，进入到WAITNG状态（无限等待）
• 创建一个老板线程（生产者）：花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子

注意：

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

Object类中的方法

void wait()

• 在其他线程调用此对象的notify()方法或notify() 方法前，导致当前线程等待。

void notify()

• 唤醒在此对象监视器上等待的单个线程。
• 会继续执行wait方法之后的代码

public class CaiNiao{
    public static void main(String[] args){
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run(){
            //一直等着买包子
            while(true){
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    syncharonized (obj){
                        System.out.println("告知老板要的包子的种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到WAITNG状态（无限等待）
                        try{
                            obj.wait();
                        }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();
                    }
                //保证等待和唤醒只能有一个在执行,需要使用同步技术
                syncharonized (obj){
                    System.out.println("花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子");
                    //做好包子之后，调用notify方法，唤醒顾客吃包子
                    obj.notify();
                }
            }
        }.start();
    }
  

Object类中wait带参方法和notify

进入到TimeWaiting（计时等待）有两种方法

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

唤醒的方法：

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

调用wait和notify方法需要注意的细节

1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这两个方法。