JAVA多线程——notify()和notifyAll()的注意事项

最新推荐文章于 2025-02-02 18:03:09 发布

Oo此岸花开oO

最新推荐文章于 2025-02-02 18:03:09 发布

阅读量671

点赞数

CC 4.0 BY-SA版权

分类专栏： java多线程 javase 文章标签：多线程 notify notifyAll wait

本文链接：https://blog.youkuaiyun.com/hqq2023623/article/details/50997237

javase 同时被 2 个专栏收录

31 篇文章

订阅专栏

java多线程

14 篇文章

订阅专栏

本文深入探讨了Java线程中的等待(wait)和通知(notify)机制，包括WAITING和BLOCKED状态的区别，以及notify和notifyAll方法的使用场景。通过生产者与消费者模式的实例演示，展示了notify()和notifyAll()方法对线程调度的影响。

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

1. - waiting on <lock id> —— 对应java.lang.Thread.State: WAITING

表示线程执行到了锁的wait()方法上

由于wait()方法会释放锁，所以当前线程此时处于未获取锁状态，等待notify() || notifyAll()

2. - waiting to lock <lock id> —— 对应java.lang.Thread.State: BLOCKED

表示锁已经被其他线程占有，该线程只能进入阻塞状态等待该锁的持有者释放锁再竞争

notify ():

从等待指定对象（调用notify的对象）的锁的线程中随机选取一个线程执行，其他线程状态仍然为waiting on

如果被选中的线程没有再执行notify或者notifyAll，这些线程可能永远处在waiting on状态

notifyAll() :

通知所有在等待指定对象的锁的线程退出waiting on状态

进入waiting to lock状态去参与锁的竞争

实例1：生产者与消费者模式

创建共享变量

public class VarHolder {

    private boolean needWait = true;

    public synchronized void doConsumer() {
        while (needWait) {
            try {
                System.out.println(Thread.currentThread().getName() + "  is going to wait()");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        needWait = true;
        System.out.println(Thread.currentThread().getName() + "   get Notified");
    }

    public synchronized void doProduce() {
        while (!needWait) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        needWait = false;
        notify();
//        notifyAll();
    }

}

创建生产者和消费者

public class Producer implements Runnable {

    private VarHolder holder;

    public Producer(VarHolder holder) {
        this.holder = holder;
    }

    @Override
    public void run() {
        holder.doProduce();
    }
}

public class Consumer implements Runnable {

    private VarHolder holder;

    public Consumer(VarHolder holder) {
        this.holder = holder;
    }

    @Override
    public void run() {
        holder.doConsumer();
    }
}

创建测试类

public class TestNotify {

    public static void main(String[] args) {
        VarHolder holder = new VarHolder();
        //启动两个消费者，一个生产者
        for (int i = 0; i < 2; i++) {
            new Thread(new Consumer(holder), "consumer-" + i).start();
        }
        //等待1s让consumer线程都进入wait()方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new Producer(holder), "producer1").start();
    }
}

分别注释notify()和notifyAll()查看运行结果：

doProduce()执行notify()的结果： 仅仅唤醒一个线程

consumer-0  is going to wait()
consumer-1  is going to wait()
consumer-0   get Notified

doProduce()执行notifyAll()的结果：

consumer-1  is going to wait()
consumer-0  is going to wait()
consumer-0   get Notified
consumer-1  is going to wait()

可以看到notifyAll()将会唤醒所有线程，导致consumer-1再次调用wait()方法