多线程之wait&notify

朴灿烈づ我的快乐病毒、 2024-03-30 10:47 86阅读 0赞

**目录：**

**前言**

**1.wait()方法**

**2 notify()方法**

**3.wait & notify的代码示例：**

**4.关于notifyAll()方法**

--------------------

### **前言** ###

线程最大的问题就是抢占式执行，随机调度。虽然线程在操作系统内核里的调度是随机的，但是可以通过一些办法来控制线程之间的执行顺序，让一些线程主动阻塞，主动放弃CPU。

示例：

现在有t1 和t2两个线程,希望t1线程先进行工作，然后工作一段时间后，再让t2线程再来工作。就可以让t2线程先进行wait(阻塞,主动放弃cpu)，等t1线程工作一段时间后，再通过notify通知t2线程，把 t2线程唤醒，让 t2线程接着工作。

**在****上述场景,使用join 或者sleep****可不可以呢？**

使用join，则必须要t1线程彻底执行完,，t2线程才能运行。如果是希望t1线程先做50%的工作，就让t2线程开始执行，使用join是办不到的，因为join要等到一个线程彻底执行完毕。使用sleep，指定一个休眠时间的，但是t1线程执行的这些工作，到底用了多少时间是不确定的。那么是可以使用**wait****和****notify****来解决的。其中，wait 需要搭配 synchronized 使用，sleep 不需要；wait 是 Object 的方法 ，sleep 是 Thread 的静态方法。**

### **1.****wait()方法** ###

wait要搭配 synchronized 来使用，脱离 synchronized 使用 wait 会直接抛出异常。

wait的操作：

释放当前的锁

使当前执行代码的线程进行阻塞等待

收到通知时被唤醒，重新尝试获取这个锁，在获取锁之后继续往下执行。

wait 结束等待的条件:

其他线程调用该对象的 notify 方法

wait 等待时间超时 (wait 方法提供一个带有 timeout 参数的版本，来指定等待时间)

其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出 InterruptedException 异常

### **2 notify()方法**  ###

notify的操作:（唤醒等待的线程）

notify()方法是用来通知同一个对象上等待的线程，对其发出通知notify，并使它们重新获取该对象的对象锁。

如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。

### 3.**wait & notify****的**代码示例： ###

**代码示例1：**

public class ThreadDemo16 {
        public static void main(String[] args) throws InterruptedException {
            Object object = new Object();
            Thread t1 = new Thread(()->{
                System.out.println("t1线程等待之前");
                try {
                    synchronized (object){
                        object.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1线程被唤醒");
            });
    
            Thread t2 = new Thread(()->{
                System.out.println("t2线程notify之前");
                synchronized (object){
                    object.notify();
                }
                System.out.println("t2线程notify之后");
            });
    
            t1.start();
            Thread.sleep(1000);//这个保证t1线程一定要先进行阻塞等待，t2才能进行唤醒
            t2.start();
        }
    }

![ae325cf6e05e478b944bbe4b7f5b3e7c.png][]

**代码示例2：三个线程顺序打印ABC**

public class ThreadDemo17 {
        public static void main(String[] args) throws InterruptedException {
            Object locker1 = new Object();
            Object locker2 = new Object();
    
            Thread t1 = new Thread(()->{
                System.out.println("A");
                synchronized (locker1){
                    locker1.notify();
                }
            });
    
            Thread t2 = new Thread(()->{
                try {
                    synchronized (locker1){
                        locker1.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                System.out.println("B");
    
                synchronized (locker2){
                    locker2.notify();
                }
            });
    
            Thread t3 = new Thread(()->{
                try {
                    synchronized (locker2){
                        locker2.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("C");
            });
            t2.start();
            t3.start();
            Thread.sleep(1000);//保证t2和t3先执行了，先进行等待
            t1.start();
        }
    }

![ebadb8f792e34f7db925d6b94a0e13d1.png][]

### 4.关于notifyAll()方法 ###

notifyAll和notify是非常相似的，当多个线程wait 的时候, notify随机唤醒一个, notifyAll所有线程都唤醒,这些线程再来一起竞争锁。

[ae325cf6e05e478b944bbe4b7f5b3e7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f7ccd5bcfb6d4837905478e591e9a66d.png
[ebadb8f792e34f7db925d6b94a0e13d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2f70a59e7eff4e3fb74b3450080a61d0.png