【juc】wait和notify原理

原创已于 2023-04-08 14:49:23 修改 · 327 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#juc

于 2023-04-06 23:09:00 首次发布

juc 专栏收录该内容

32 篇文章

订阅专栏

文章详细介绍了Java中的Monitor锁结构，包括waitset和entrylist的概念，以及wait、notify和notifyAll方法的原理和使用。在synchronized块中，线程调用wait会释放锁进入等待，而notify和notifyAll会唤醒等待的线程，这些线程需要重新竞争锁。示例代码展示了wait方法的使用限制和时间参数的影响，以及notify和notifyAll唤醒线程的不同行为。

1.线程1一开始持有对象A的monitor锁，即monitor中的owner指向线程1
2.线程1在执行的过程中发现条件a不满足执行不下去了，此时线程1可以调用wait方法，那么线程1就进入waitset进行等待，状态为waiting
3.线程4准备给对象A加锁，发现当前对象A的monitor的owner是线程2，线程4则会进入entryList中准备竞争
4.waitset和entrylist中的线程都处于阻塞状态，不会占用cpu的时间片
5.waitset中的线程是获取到了锁，但又主动放弃了锁；entrylist中的线程是准备加锁时发现锁已经被其它线程占用，而获取不到锁
6.waitset中的线程1和线程3会在owner指向的线程1调用notify或者notifyAll时唤醒，被唤醒后，不会立刻获得锁，还是要进入entrylist等待下一次竞争

三、api说明

1.obj.wait()：synchronized(obj){代码块}，代码块wait方法让进入obj监视器的线程到monitor的waitset中等待
2.obj.notify()在obj的monitor的waitset中等待的线程中挑一个唤醒
3.obj.notifyAll()在obj的monitor的waitset中等待的所有线程全部唤醒
4.wait、notify、notifyAll方法都是在线程之间进行协作的手段，都属于Object对象的方法，必须获得此对象的锁才能调用这几个方法

四、api使用

4.1 wait方法

1.wait方法需要放synchronized代码块里,否则运行会报IllegalMonitorStateException异常
2.对象执行wait方法后，该线程会进入阻塞，其它线程可以竞争到对象的monitor

package com.learning.wait;

/**
 * @Author wangyouhui
 * @Description 对象的wait方法必须放synchronized代码块里
 **/
public class WaitLearning {
    static final Object lock = new Object();
    public static void main(String[] args) {
        try {
            lock.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.learning.wait.WaitLearning.main(WaitLearning.java:11)

3.在synchronized代码块中执行等待，获得锁的主线程一直在等待，阻塞中

package com.learning.wait;

/**
 * @Author wangyouhui
 * @Description 对象的wait方法必须放synchronized代码块里
 **/
public class WaitLearning {
    static final Object lock = new Object();
    public static void main(String[] args) {
        synchronized (lock) {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.wait(时间),当超过等待时间会自动唤醒

package com.learning.wait;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author wangyouhui
 * @Description 对象的wait时间方法，当时间过去后，会继续执行
 **/
@Slf4j
public class WaitTimeLearning {
    static final Object lock = new Object();
    public static void main(String[] args) {
        new Thread(()->{
            synchronized (lock) {
                try {
                    log.info("线程1等待");
                    lock.wait(2000);
                    log.info("线程1继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "thread1").start();
    }
}

在这里插入图片描述

5.wait(时间),等待时间内被其它线程唤醒会提前唤醒

package com.learning.wait;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author wangyouhui
 * @Description 对象的wait时间方法，当时间过去后，会继续执行
 **/
@Slf4j
public class WaitTimeLearning2 {
    static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (lock) {
                try {
                    log.info("线程1等待");
                    lock.wait(2000);
                    log.info("线程1继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "thread1").start();

        Thread.sleep(1000);

        synchronized (lock){
            log.info("主线程唤醒");
            lock.notify();
        }
    }
}

在这里插入图片描述

4.2 notify方法

1.notify方法需要放在synchronized代码块中，notify方法只能唤醒waitset中的一个线程

package com.learning.notify;

import lombok.extern.slf4j.Slf4j;


/**
 * @Author wangyouhui
 * @Description notify方法从waitset中挑选一个等待的线程唤醒
 **/
@Slf4j
public class NotifyLearning {
    static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (lock){
                log.info("线程1等待");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("线程1继续执行");
            }
        }, "thread1").start();
        new Thread(()->{
            synchronized (lock){
                log.info("线程2等待");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("线程2继续执行");
            }
        }, "thread2").start();

        Thread.sleep(2000);
        synchronized (lock){
            log.info("主线程拿到锁，执行lock.notify方法，唤醒waitset中的一个线程");
            lock.notify();
        }
    }
}

 [thread1] INFO com.learning.notify.NotifyLearning - 线程1等待
 [thread2] INFO com.learning.notify.NotifyLearning - 线程2等待
 [main] INFO com.learning.notify.NotifyLearning - 主线程拿到锁，执行lock.notify方法，唤醒waitset中的一个线程
 [thread1] INFO com.learning.notify.NotifyLearning - 线程1继续执行

4.3 notifyAll方法

1.notifyAll方法将waitset中所有等待的线程都唤醒

package com.learning.notifyall;
import lombok.extern.slf4j.Slf4j;
/**
 * @Author wangyouhui
 * @Description notifyAll方法将waitset中所有等待的线程都唤醒
 **/
@Slf4j
public class NotifyAllLearning {
    static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (lock){
                log.info("线程1等待");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("线程1继续执行");
            }
        }, "thread1").start();
        new Thread(()->{
            synchronized (lock){
                log.info("线程2等待");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("线程2继续执行");
            }
        }, "thread2").start();

        Thread.sleep(2000);
        synchronized (lock){
            log.info("主线程拿到锁，执行lock.notify方法，唤醒waitset中的一个线程");
            lock.notifyAll();
        }
    }
}

[thread1] INFO com.learning.notifyall.NotifyAllLearning - 线程1等待
[thread2] INFO com.learning.notifyall.NotifyAllLearning - 线程2等待
[main] INFO com.learning.notifyall.NotifyAllLearning - 主线程拿到锁，执行lock.notify方法，唤醒waitset中的一个线程
 [thread2] INFO com.learning.notifyall.NotifyAllLearning - 线程2继续执行
[thread1] INFO com.learning.notifyall.NotifyAllLearning - 线程1继续执行