2.线程的通知与等待

古城微笑少年丶 2022-10-28 03:54 162阅读 0赞

## 1.2 线程的通知与等待 ##

> java 中所有类都继承至Object类，所以就把锁定义给放到了Object类中。

### 1.2.1 wait方法 ###

**wait**方法可以释放当前锁对象，但是不能释放其他线程的锁对象。释放后就进入阻塞状态。  
**唤醒方法：**

1.  其他线程调用该锁对象的notify()、notifyAll()方法将其唤醒。
2.  其他线程调用该锁对象的interrupt()方法，该方法会抛出异常并返回。

**注意：** 如果没有获取锁对象获取该锁就调用该对象的Wait方法，则时调用线程会抛出IllegalMonitorStateException异常。

/**
     * @date 2020-1-22
     * @author 49800
     */
    public class WaitNotifyInterupt {
        
        static Object obj = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            Thread thread = new Thread(new Runnable() {
        
                @SneakyThrows
                @Override
                public void run() {
        
                    synchronized (obj) {
        
                        System.out.println("进入object锁");
                        obj.wait();
                        System.out.println("这句话不该显示");
                    }
                    System.out.println("运行结束");
                }
            });
    
            thread.start();
            System.out.println("开始运行interrupt");
            // 如果一个线程调用wait()方法后,在调用终端则会报错返回.
            thread.interrupt();
            System.out.println("main方法运行结束");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDgwNjc3Mg_size_16_color_FFFFFF_t_70_pic_center]  
  当此线程被挂起时，没有获取监视器锁得线程调用interrupt()方法，就会抛出.InterruptedException并返回。

#### wait(long timeOut)函数 ####

该方法比原来的方法多了一个超时时间，他的不同之处在于当线程被挂载，没有在指定的超时时间内被notify()、notifyAll()方法唤醒，则会因为超时而返回。如果超时时间填写0则和上个方法的作用是一样的。如果填写负数，则会抛出IllegalArgumentException异常。

**Notify**：一个对象调用共享对象的notify()方法，会唤醒一个在该共享对象调用Wait()方法的被挂载的线程。一个共享变量上可能有多个线程在等待，具体唤醒的哪个等待线程是随机的。  
**NotifyAll**(): 一个对象调用共享对象的notifyAll()对下个，就会唤醒这个共享对象的所有对象。

下面是示例：可以复制粘贴下试试看。

/**
     * @author 49800
     * @date 2020-1-25
     */
    public class NotifyTest {
        
        private static Object object = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            Thread threadA = new Thread(() -> {
        
                // 开始进入object锁
                System.out.println("1开始进入object锁");
                synchronized (object) {
        
                    System.out.println("1进入了内部");
                    try {
        
                        object.wait();
                        System.out.println("这句话一定要显示");
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
    
            Thread threadB = new Thread(() -> {
        
                // 开始进入object锁
                System.out.println("2开始进入object锁");
                synchronized (object) {
        
                    System.out.println("2进入了内部");
                    try {
        
                        object.wait();
                        System.out.println("aaa");
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
    
            Thread threadC = new Thread(() -> {
        
                // 开始进入object锁
                System.out.println("3开始进入object锁");
                synchronized (object) {
        
                    System.out.println("3进入了内部");
                    try {
        
                        object.wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
    
            Thread threadD = new Thread(() -> {
        
                synchronized (object){
        
                    System.out.println("解开锁");
                    //object.notifyAll();
                    object.notifyAll();
                }
            });
    
            threadA.start();
            Thread.sleep(2000);
            threadB.start();
            threadC.start();
            threadD.start();
    
            threadA.join();
            threadB.join();
            threadC.join();
            threadD.join();
            System.out.println("main结束");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDgwNjc3Mg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/c9778c6f627d420bb7fb0bfb55408377.png