多线程学习--等待/通知机制

谁践踏了优雅 2024-02-19 14:35 12阅读 0赞

等待/通知机制：多个线程彼此之间进行交互与线程之间的依赖，一个线程等待这其他线程的唤醒。

实现方式：wait()/notify()/notifyall().

wait():使当前的执行代码的线程进行等待，wait()是Object类中的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到节到通知或 中断为止。同时在调用该方法之前，线程必须获得该对象的线程锁，即只能在同步方法或同步代码块中调用。执行该方法后，释放线程锁。其他线程唤醒后，需要重新与其他线程争抢线程锁。

notify()：唤醒等待的线程，跟wait()方法一样，需要在同步方法或同步代码块中使用，即调用之前需要获取到该对象的线程锁。在执行该方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也不能马上获取该对象锁，要等到执行notify()方法的线程将程序运行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈现wait()状态的线程才可以获取该对象锁。如果由多个线程等待，则随机唤醒一个线程。

notifyAll():使所有正在等待队列中等待同一共享资源的“全部”线程从等待状态退出，进入可运行状态。优先级最高的线程最先运行，但也有可能使随机执行，这取决于JVM虚拟机的实现。

总之：wait():使线程停止运行。notify():使停止的线程继续运行。notifyAll()：唤醒所有的等待线程。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

wait()永远阻塞，在没有唤醒的前提下：

public class Run_wait {
        public static void main(String[] args) {
            try {
                String lock = new String();
                System.out.println("syn上面");
                synchronized (lock) {
                    System.out.println("syn第一行,wait前面");
                    lock.wait();
                    System.out.println("wait下面的代码");
                }
                System.out.println("syn下面的代码");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

没有“对象监视器”，调用wait()方法出现运行时异常：

public class Run_noObjectLock {
        public static void main(String[] args) {
            String s = new String("");
            try {
                s.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

结果：

Exception in thread "main" java.lang.IllegalMonitorStateException
    	at java.lang.Object.wait(Native Method)
    	at java.lang.Object.wait(Object.java:502)
    	at com.brianway.learning.java.multithread.communication.example2.Run2_noObjectLock.main(Run2_noObjectLock.java:15)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:483)
    	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

wait()等待/notify实现通知：

notify调用后，并不会立即释放对象锁，而是退出synchronized代码块后

当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象

public class RunNotify {
        public static void main(String[] args) {
            try {
                Object lock = new Object();
                new Thread(()->{
                    try {
                        synchronized (lock) {
                            System.out.println("开始 wait   time=" + System.currentTimeMillis());
                            lock.wait();
                            System.out.println("结束 wait   time=" + System.currentTimeMillis());
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                },"A").start();
                Thread.sleep(3000);
                new Thread(()->{
                    synchronized (lock) {
                        System.out.println("开始 notify time=" + System.currentTimeMillis());
                        lock.notify();
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("结束 notify time=" + System.currentTimeMillis());
                    }
    
                },"B").start();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    }

结果：

开始 wait   time=1544626559493
    开始 notify time=1544626562494
    结束 notify time=1544626564495
    结束 wait   time=1544626564495

唤醒所有：

class MyService {
        public void testMethod(Object lock) {
            try {
                synchronized (lock) {
                    System.out.println("begin wait(),ThreadName=" + Thread.currentThread().getName());
                    lock.wait();
                    System.out.println("end wait(),ThreadName=" + Thread.currentThread().getName());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public class Run_notifyAll {
        public static void main(String[] args) throws InterruptedException {
            Object lock = new Object();
    
            new Thread(()->{
                MyService myService=new MyService();
                myService.testMethod(lock);
            },"A").start();
    
            new Thread(()->{
                MyService myService=new MyService();
                myService.testMethod(lock);
            },"B").start();
    
            new Thread(()->{
                MyService myService=new MyService();
                myService.testMethod(lock);
            },"C").start();
    
    
            Thread.sleep(1000);
    
            new Thread(()->{
                synchronized (lock) {
                    //唤醒所有
                    lock.notifyAll();
                }
            },"D").start();
    
    
        }
    }

结果：

begin wait(),ThreadName=B
    begin wait(),ThreadName=C
    begin wait(),ThreadName=A
    end wait(),ThreadName=A
    end wait(),ThreadName=C
    end wait(),ThreadName=B

多个线程共享同一把锁，都处于等待状态，notify()一次只能唤醒一个线程，其他线程一直出于等待状态，如果不唤醒一直等待到死亡。

测试：将上面的线程D换成

new Thread(()->{
                synchronized (lock) {
                    //唤醒一个
                    lock.notify();
                }
    },"D").start();

结果：一个线程被唤醒，另外两个一直出于阻塞等待状态。

唤醒多个线程：

测试：将上面线程D换成

new Thread(()->{
                synchronized (lock) {
                    //唤醒多个
                    lock.notify();
                    lock.notify();
                    lock.notify();
                    lock.notify();
                }
            },"D").start();

结果：等待的三个线程都被唤醒了。

wait(long)使用，超时自动唤醒：

public class RunwaitHasParam {
        static private Object lock = new Object();
        static private Runnable runnable1 = new Runnable() {
            public void run() {
                try {
                    synchronized (lock) {
                        System.out.println("wait begin timer=" + System.currentTimeMillis());
                        lock.wait(4000);
                        System.out.println("wait end timer=" + System.currentTimeMillis());
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
    
        public static void main(String[] args) {
            Thread t = new Thread(runnable1);
            t.start();
        }
    }

结果：

wait begin timer=1544627664372
    wait end timer=1544627668374

wait(long)使用，时间限制内由其他线程唤醒：

public class RunwaitHasParam2 {
        static private Object lock = new Object();
        static private Runnable runnable1 = new Runnable() {
            public void run() {
                try {
                    synchronized (lock) {
                        System.out.println("wait begin timer=" + System.currentTimeMillis());
                        lock.wait(5000);
                        System.out.println("wait end timer=" + System.currentTimeMillis());
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
    
        static private Runnable runnable2 = new Runnable() {
            public void run() {
    
                synchronized (lock) {
                    System.out.println("notify begin timer=" + System.currentTimeMillis());
                    lock.notify();
                    System.out.println("notify end timer=" + System.currentTimeMillis());
                }
    
            }
        };
    
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(runnable1);
            t1.start();
            Thread.sleep(2000);
            Thread t2 = new Thread(runnable2);
            t2.start();
        }
    }

结果：

wait begin timer=1544627702785
    notify begin timer=1544627704784
    notify end timer=1544627704784
    wait end timer=1544627704785

wait()状态执行interrupt()方法：

结果：

begin wait(),ThreadName=A
    java.lang.InterruptedException
    	at java.lang.Object.wait(Native Method)
    	at java.lang.Object.wait(Object.java:502)
    	at com.brianway.learning.java.multithread.communication.example3.MyService.testMethod(Run3_notifyAll.java:16)
    	at com.brianway.learning.java.multithread.communication.example3.Run3_notifyAll.lambda$main$0(Run3_notifyAll.java:29)
    	at java.lang.Thread.run(Thread.java:748)

等待wait()条件发生了变化：

class AddLock {
        private String lock;
    
        public AddLock(String lock) {
            super();
            this.lock = lock;
        }
    
        public void add() {
            synchronized (lock) {
                ValueObject.list.add("anyString");
                lock.notifyAll();
            }
        }
    }
    public class Run6_waitOld {
        public static void main(String[] args) throws InterruptedException {
            String lock = new String("");
            Add add = new Add(lock);
            new Thread(()->{
                try {
                    synchronized (lock) {
                        if (ValueObject.list.size() == 0) {
                            System.out.println("begin wait(),ThreadName=" + Thread.currentThread().getName());
                            lock.wait();
                            System.out.println("end wait(),  ThreadName=" + Thread.currentThread().getName());
                        }
                        ValueObject.list.remove(0);
                        System.out.println("list size = " + ValueObject.list.size());
                    }
    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"A").start();
    
            new Thread(()->{
                try {
                    synchronized (lock) {
                        if (ValueObject.list.size() == 0) {
                            System.out.println("begin wait(),ThreadName=" + Thread.currentThread().getName());
                            lock.wait();
                            System.out.println("end wait(),  ThreadName=" + Thread.currentThread().getName());
                        }
                        ValueObject.list.remove(0);
                        System.out.println("list size = " + ValueObject.list.size());
                    }
    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"B").start();
    
            Thread.sleep(1000);
    
            new Thread(()->{
                add.add();
            },"C").start();
    
        }
    }

结果：

begin wait(),ThreadName=A
    begin wait(),ThreadName=B
    end wait(),  ThreadName=B
    list size = 0
    Exception in thread "A" end wait(),  ThreadName=A
    java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
    	at java.util.ArrayList.rangeCheck(ArrayList.java:657)
    	at java.util.ArrayList.remove(ArrayList.java:496)
    	at com.brianway.learning.java.multithread.communication.example6.Run6_waitOld.lambda$main$0(Run6_waitOld.java:38)
    	at java.lang.Thread.run(Thread.java:748)

说明：启动后两个执行减法的线程进入了等待状态，等了1秒后，唤醒线程执行了，因其一次性唤醒了所有的等待线程导致，执行减法的两个线程都进入了运行状态，从而导致了集合的下标越界。

总结：

执行完同步代码块就会释放对象锁。

在执行同步代码块的过程中，遇到异常而导致线程停止，锁也会释放。

在执行同步代码块的过程中，执行了锁所属对象的等待方法，这个线程会释放对象锁，而线程对象会进入线程等待池中，等待被唤醒。

虽然可以使用sleep()与while(true)也可以实现线程通信，但是非常不建议使用，应为死循环当作监听器使非常消耗cpu的资源，性能特别差。

等待和唤醒的顺序需要注意，没有等待的线程，执行唤醒功能就没有任何意义。同时等待wait()条件发生了变化也有可能会造成错误。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/07999dc43c464e979c404b6d95026c9e.png