线程通知与等待

最新推荐文章于 2024-11-05 11:00:12 发布

原创最新推荐文章于 2024-11-05 11:00:12 发布 · 267 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#wait #notify #多线程

并发编程专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍了多线程编程中共享变量的wait()、wait(long timeout)和notify()函数。wait()使线程阻塞，需特定条件唤醒，要防范虚假唤醒；wait(long timeout)可设置超时返回；notify()唤醒一个等待线程，notifyAll()唤醒所有等待线程，调用这些函数需先获取监视器锁。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

wait() 函数

当一个线程调用一个共享变量的 wait() 方法时，该调用线程会被阻塞挂起，直到发生下面几件事情之一才返回。

其他线程调用了该共享对象的 notify() 或者 notify() 方法；
其他线程调用了该线程的 interrupt() 方法，该线程抛出 InterruptedException 异常返回。

注意：如果调用 wait() 方法的线程没有事先获取该对象的监视器锁（synchronized），则调用wait() 方法时，调用线程会抛出 IllegalMonitorException 异常。

一个线程可以从挂起状态变为可以运行状态（也就被唤醒），即使该线程没有被其他线程调用 notify() 、notifyAll() 方法进行通知，或者被中断，或者等待超时，这就是所谓的虚假唤醒。

避免虚假唤醒：不停地去测试该线程被唤醒的条件是否满足，不满足则继续等待，也就是说在一个循环中调用 wait() 方法进行防范，退出循环的条件是否满足唤醒该线程的条件。

synchronized(obj){
    while(条件不满足){
        obj.wait();
    }
}

首先通过同步块获取 obj 上面的监视器锁，然后再 while 循环内调用 obj 的 wait()方法。

当前线程调用共享变量的 wait() 方法后只会释放当前共享变量上的锁，如果当前线程还持有其他共享变量的锁，则这些锁是不会被是释放的。

public class WaitTest {

    private static volatile Object resourceA = new Object();
    private static volatile Object resourceB = new Object();

    public static void main(String[] args) throws InterruptedException {
        //创建线程
         Thread threadA = new Thread(new Runnable() {
            public void run() {
                try {
                    //获取 resourceA 共享资源的监视器锁
                    synchronized (resourceA){
                        System.out.println("threadA get resourceA lock");

                        //获取 resourceB 共享资源的监视器锁
                        synchronized (resourceB){
                            System.out.println("threadA get resourceB lock");

                            //线程A阻塞，并释放获取到的 resourceA 的锁
                            System.out.println("threadA release resourceA lock");
                            resourceA.wait();
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });


        //创建线程
        Thread threadB = new Thread(new Runnable() {
            public void run() {
                try {
                    //休眠 1 秒
                    Thread.sleep(1000);
                    //获取 resourceA 共享资源的监视器锁
                    synchronized (resourceA){
                        System.out.println("threadB get resourceA lock");

                        System.out.println("threadB try get resourceB lock");

                        //获取 resourceB 共享资源的监视器锁
                        synchronized (resourceB){
                            System.out.println("threadB get resourceB lock");
                            //线程B阻塞，并释放获取到的 resourceA 的锁
                            System.out.println("threadB release resourceA lock");
                            resourceB.wait();
                        }

                    }


                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        //启动线程
        threadA.start();
        threadB.start();

        //等待两个线程结束
        threadA.join();
        threadB.join();

        System.out.println("main over");
    }

}

当一个线程调用共享对象的 wait() 方法被阻塞挂起后，如果其他线程中断了该线程，则线程会抛出 InterrupttedException 异常并返回。

public class WaitNotifyInterrupt {
    static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread threadA = new Thread(new Runnable() {
            public void run() {
                try {
                    System.out.println("----开始---");
                    //阻塞当前线程
                    synchronized (obj){
                        wait();
                    }
                    System.out.println("---结束---");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        threadA.start();

        Thread.sleep(1000);

        System.out.println("开始中断线程A");
        threadA.interrupt();
        System.out.println("结束中断线程A");
    }
}

wait(long timeout) 函数

如果一个线程调用共享对象的该方法挂起后，没有在指定的 timeout ms 时间内内被其他线程调用该共享变量的 notify() 或者 notifyAll() 方法唤醒，那么该函数还是会因为超时而返回。如果将 timeout 设置为 0 则和 wait 方法效果一样，因为在 wait 方法内部就是调用了 wait(0)。需要注意的是，如果在调用该函数时，传递了一个负的 timeout 则会抛出 IllegalArgumentWException 异常。

notify() 函数

一个线程调用共享对象的 notify() 方法后，会唤醒一个在该共享变量上调用 wait 系列方法后被挂起的线程。一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。

被唤醒的线程不能退马上从 wait 方法返回并继续执行，它必须在获取了共享对象的监视器锁后才可以返回，也就是唤醒它的线程释放了共享变量上的监视器锁后，被唤醒的线程也不一定会获取到共享对象的监视器锁，这是因为该线程还需要和其他线程一起竞争该锁，只有该线程竞争到了共享变量的监视器锁后才可以继续执行。

类似 wait 系列方法，只有当线程获取到了共享变量的监视器锁后，才可以调用共享变量的 notify() 方法，否则会抛出 IllegalMonitorStateException 异常

不同于在共享变量上调用 notify() 函数会唤醒被阻塞到该共享变量上的一个线程，notifyAll() 方法则会唤醒所有在该共享变量上由于 wait 系列方法而被挂起的线程。

public class WaitNotify {
    //创建资源
    private static volatile Object resourceA = new Object();

    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread threadA = new Thread(new Runnable() {
            public void run() {

                //获取 resourceA 共享资源的监视器锁
                synchronized (resourceA){
                    System.out.println("threadA get resourceA lock");
                    try {
                        System.out.println("threadA 开始阻塞");
                        resourceA.wait();
                        System.out.println("theadA 结束阻塞");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        //创建线程
         Thread threadB = new Thread(new Runnable() {
            public void run() {
               synchronized (resourceA){
                   System.out.println("threadB get resourceA lock");

                   try {
                       System.out.println("threadB 开始阻塞");
                       resourceA.wait();
                       System.out.println("theadB 结束阻塞");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            }
        });

         //创建线程
        Thread threadC = new Thread(new Runnable() {
            public void run() {
                synchronized (resourceA){
                    System.out.println("threadC 开始唤醒");
                    resourceA.notify();
                }
            }
        });

        //启动线程
        threadA.start();
        threadB.start();
        Thread.sleep(1000);
        threadC.start();

        //等待线程结束
        threadA.join();
        threadB.join();
        threadC.join();

        System.out.println("主线程结束。。。");
    }
}