Java使用wait/notify实现线程间通信下篇_Java教程_编程语言

Java使用wait/notify实现线程间通信下篇

2023-02-09 学习力0

核心提示：目录1. 当 interrupt() 方法遇到 wait() 方法2. notify() 只通知一个线程3. notifyAll() 唤醒所有线程4. 方法 wait(long)的使用上一节针对wait/notify实现线程间通信的基本概念做了讲解（Java使用wait/notify实现线程间通信上篇），本节继续针对wait/notify实

1. 当 interrupt() 方法遇到 wait() 方法

当线程调用锁对象的wait() 方法使线程呈等待状态时，调用线程对象的 interrupt() 方法会出现 InterruptedException 异常。

public class ThreadC7 {
    @Test
    public void test1() {
        try {
            Object obj = new Object();
            ThreadC7A threadC7A = new ThreadC7A(obj);
            threadC7A.start();
            Thread.sleep(2000);
            threadC7A.interrupt();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class ServiceC7 {
    public void testMethod(Object obj) {
        try {
            synchronized (obj) {
                System.out.println("begin wait");
                obj.wait();
                System.out.println("begin end");
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("出现异常了，wait状态的线程被interrupt了！");
        }
    }
}
class ThreadC7A extends Thread {
    private Object obj;
    public ThreadC7A(Object obj) {
        this.obj = obj;
    }
    @Override
    public void run() {
        ServiceC7 serviceC7 = new ServiceC7();
        serviceC7.testMethod(obj);
    }
}

执行结果：

Java使用wait/notify实现线程间通信下篇

2. notify() 只通知一个线程

调用方法notify()一次只随机通知一个线程进行唤醒。

public class ThreadC8 {
    @Test
    public void test() {
        Object obj = new Object();
        ThreadC8A threadC8A = new ThreadC8A(obj);
        threadC8A.setName("threadC8A");
        threadC8A.start();
        ThreadC8B threadC8B = new ThreadC8B(obj);
        threadC8B.setName("threadC8B");
        threadC8B.start();
        ThreadC8C threadC8C = new ThreadC8C(obj);
        threadC8C.setName("threadC8C");
        threadC8C.start();
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        synchronized (obj) {
            obj.notify();
        }
        while (Thread.activeCount() > 1) {
        }
    }
}
class ServiceC8 {
    public void service(Object obj) {
        try {
            synchronized (obj) {
                String threadName = Thread.currentThread().getName();
                System.out.println("begin wait，Thread Name:[" + threadName + "]");
                obj.wait();
                System.out.println("end wait，Thread Name:[" + threadName + "]");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class ThreadC8A extends Thread {
    private Object obj;
    public ThreadC8A(Object obj) {
        this.obj = obj;
    }
    @Override
    public void run() {
        ServiceC8 serviceC8 = new ServiceC8();
        serviceC8.service(obj);
    }
}
class ThreadC8B extends Thread {
    private Object obj;
    public ThreadC8B(Object obj) {
        this.obj = obj;
    }
    @Override
    public void run() {
        ServiceC8 serviceC8 = new ServiceC8();
        serviceC8.service(obj);
    }
}
class ThreadC8C extends Thread {
    private Object obj;
    public ThreadC8C(Object obj) {
        this.obj = obj;
    }
    @Override
    public void run() {
        ServiceC8 serviceC8 = new ServiceC8();
        serviceC8.service(obj);
    }
}

执行结果：

Java使用wait/notify实现线程间通信下篇

程序运行的效果如图所示，可以看出方法notify()仅随机唤醒一个线程。

当多次调用notify()方法时，会随机将等待wait状态的线程进行唤醒。更改代码如下：

Java使用wait/notify实现线程间通信下篇

再次运行，程序运行效果如图所示，可以看出所有的线程全部被唤醒。

Java使用wait/notify实现线程间通信下篇

多次调用notify()方法可唤醒全部WAITING中的线程。

3. notifyAll() 唤醒所有线程

前面的示例中通过多次调用 notify() 方法来实现唤醒3个线程，但并不能保证系统中仅有3个线程，也就是若notify()方法的调用次数小于线程对象的数量，会出现有部分线程对象无法被唤醒的情况。为了唤醒全部线程，可以使用notifyAll()方法。

更改代码如下：

Java使用wait/notify实现线程间通信下篇

再次运行，程序运行效果如图所示，可以看出所有的线程全部被唤醒。

Java使用wait/notify实现线程间通信下篇

4. 方法 wait(long)的使用

带一个参数的wait(long) 方法的功能是等待某一时间内是否有现成对锁进行唤醒，如果超过这个时间则自动唤醒。

public class ThreadC9 {
    @Test
    public void test() {
        Object obj = new Object();
        ThreadC9A threadC9A = new ThreadC9A(obj);
        threadC9A.start();
        while (Thread.activeCount() > 1) {
        }
    }
}
class ThreadC9A extends Thread {
    private Object obj;
    public ThreadC9A(Object obj) {
        this.obj = obj;
    }
    @Override
    public void run() {
        try {
            synchronized (obj) {
                long startTime = System.currentTimeMillis();
                System.out.println("begin wait，time:[" + startTime + "]");
                obj.wait(5000);
                long endTime = System.currentTimeMillis();
                System.out.println("end wait，time:[" + endTime + "] takes " + (endTime - startTime) + " ms");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果：

Java使用wait/notify实现线程间通信下篇

通过执行结果可以看出，在经过5000ms后，线程被唤醒。

原文地址：https://blog.csdn.net/weixin_37585619/article/details/126269198

免责声明：本文仅代表作者个人观点，与乐学笔记（本网）无关。其原创性以及文中陈述文字和内容未经本站证实，对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺，请读者仅作参考，并请自行核实相关内容。
本网站有部分内容均转载自其它媒体，转载目的在于传递更多信息，并不代表本网赞同其观点和对其真实性负责，若因作品内容、知识产权、版权和其他问题，请及时提供相关证明等材料并与我们留言联系，本网站将在规定时间内给予删除等相关处理.