线程间协作:wait,notify,notifyAll，join,yield

最新推荐文章于 2022-09-08 16:52:31 发布

原创最新推荐文章于 2022-09-08 16:52:31 发布 · 461 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线程 #对象

java并发编程专栏收录该内容

12 篇文章

订阅专栏

本文详细解析了Java中Object类的wait与notify方法的使用方式及注意事项，包括如何避免notify信号丢失等问题，并通过生产者消费者模型进行了实例演示。

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

wait

1.wait,notify,notifyAll是Object类的方法。在使用时必须包含在synchronized方法中或者同步块中。即必须先获得正确的对象锁，调用wait后，会释放自己占有的锁并且加入到等待池中等待。直到有其他线程调用同一个对象的notify/notifyAll方法才会唤醒。如果在没有获得对象锁之前调用wait,notify,notifyAll会抛出IllegalMonitorStateException异常。

2.wait(long timeout)和wait(long timeout, int nanos)可以设置一个最长等待时间，如果超过这个时间，那么就不在等待，timeout的单位是毫秒，nanos的单位是纳秒。但是wait(0)和wait(0,0)相当于wait()

3.唤醒条件：

notify：其他线程调用notify时，将从等待池中随机选择一个等待线程唤醒。
notifyAll：其他线程调用notifyAll会唤醒等待池中的所有线程。
Interrupt:wait执行前或者执行中，线程发生中断，此时会抛出InterruptedException异常。
虚假唤醒：等待的线程可能会莫名其妙被唤醒(尽管发生的概率很小)，所以API文档中推荐的写法是使用while而不是if。这样如果发生虚假唤醒，会再次进入等待状态。

synchronized (obj) {
    while (<condition does not hold>)
        obj.wait(timeout);
         ... // Perform action appropriate to condition
   }

notify

线程在调用notify之后，会随机从等待池中选择一个等待线程唤醒，但是是在当前执行的同步块或者同步方法调用结束之后才会释放对象锁，等待的线程只有获得对象锁之后才能继续执行。而其他没有被唤醒的线程会继续等待。他们等待的是notify/notifyAll

notifyAll

线程调用notifyAll之后会唤醒等待池中全部线程，但是由于只能有一个线程获得对象锁，所有其他线程还得等待，但是这时他们等待的是对象锁。

例子：

1.实现生产者消费者问题

public class Wait {
    public static void main(String[] args){
        Queue<Integer> queue = new LinkedList<Integer>();
        Thread thread1 = new Thread(new Producter(queue));
        Thread thread2 = new Thread(new Consumer(queue));
        thread2.start();
        thread1.start();
    }
}

class Consumer implements Runnable {
    private Queue<Integer> queue;
    public Consumer(Queue<Integer> queue){
        this.queue = queue;
    }

    private void get() throws InterruptedException{
        synchronized(queue){
            while(queue.size() <= 0)
                queue.wait();
            System.out.println("consumer get:" + queue.poll());
            queue.notify();
        }
    }

    @Override
    public void run(){
        for(int i = 0; i < 5; i++){
            try {
                get();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

class Producter implements Runnable{
    private Queue<Integer> queue;
    Random rand = new Random();

    public Producter(Queue<Integer> queue){
        this.queue = queue;
    }

    private void put() throws InterruptedException{
        int a = rand.nextInt(100);
        synchronized(queue){
            while(queue.size() >= 1)
                queue.wait();
            queue.offer(a);
            System.out.println("producter put" + a);
            queue.notify();
        }
    }
    @Override
    public void run(){
        for(int i = 0; i < 5; i++){
            try {
                put();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }   
}