您的位置:

Java并发编程之wait方法使用

Java中的wait方法是多线程中常用的一种同步方式,它的作用是让线程进入等待状态,直到其他线程调用notify或者notifyAll方法唤醒它。在控制线程同步方面,wait方法的使用是非常必要的。

一、wait方法基本用法

wait方法用于等待其他线程的通知,并且会释放锁资源。下面是wait方法的基本用法:

try {
    synchronized (this) {
        wait();
    }
} catch (InterruptedException e) {
    e.printStackTrace();
}

在上述代码中,首先获取对象锁,然后调用wait方法使当前线程进入等待状态,直到其他线程调用notify或者notifyAll方法唤醒它。当线程进入等待状态后,所占用的锁资源会被释放出来,其他线程就可以获取这个锁。

在wait方法上,也可以设置等待的最大时间,如果在等待时间内没有被唤醒,线程就会自动苏醒。具体的代码如下:

try {
    synchronized (this) {
        wait(1000);
    }
} catch (InterruptedException e) {
    e.printStackTrace();
}

在上述代码中,等待时间为1000毫秒,如果在此时间内没有被唤醒,线程就会自动苏醒。

二、notify和notifyAll方法

notify方法用于唤醒一个等待中的线程,而notifyAll方法用于唤醒所有等待中的线程。

以下是notify和notifyAll方法的用法示例:

try {
    synchronized (this) {
        notify();
        // 或者notifyAll();
    }
} catch (Exception e) {
    e.printStackTrace();
}

三、wait和notify的经典应用场景

1. 生产者和消费者问题

生产者和消费者问题是多线程中常见的一种同步问题。生产者和消费者共同使用一个队列,生产者向队列中生产数据,消费者从队列中取出数据。如果队列已经满了,生产者就需要等待消费者取走数据以后才能继续生产,如果队列已经空了,消费者就需要等待生产者生产数据以后才能继续消费。

下面是使用wait和notify来解决生产者和消费者问题的经典实现:

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumer {
    private final Queue<Object> queue = new LinkedList<>();
    private final int MAX_SIZE = 10;

    public void produce(Object obj) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == MAX_SIZE) {
                System.out.println("队列已满,生产者等待...");
                queue.wait();//队列已满,等待消费者消费
            }
            queue.add(obj);//生产一个元素
            System.out.println("生产者生产了一个元素,队列中元素个数:" + queue.size());
            queue.notifyAll();//唤醒所有消费者线程
        }
    }

    public void consume() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                System.out.println("队列为空,消费者等待...");
                queue.wait(); //队列为空,等待生产者生产
            }
            Object obj = queue.poll();//消费一个元素
            System.out.println("消费者消费了一个元素,队列中元素个数:" + queue.size());
            queue.notifyAll();//唤醒所有生产者线程
        }
    }
}

2. 等待-通知机制的使用

在多线程中,基于等待-通知机制来进行协作,是实现同步的重要方式之一。下面是一个使用等待-通知机制来协作的实例:

public class WaitNotifyDemo {
    private static volatile boolean flag = false;
    private static final Object obj = new Object();

    public static void main(String[] args) {
        Thread waitThread = new Thread(new WaitTask(), "WaitThread");
        waitThread.start();
        SleepUtils.second(1);
        Thread notifyThread = new Thread(new NotifyTask(), "NotifyThread");
        notifyThread.start();
    }

    static class WaitTask implements Runnable {
        public void run() {
            synchronized (obj) {
                while (!flag) {
                    System.out.println(Thread.currentThread() + " flag is false. wait...");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread() + " flag is true. running...");
            }
        }
    }

    static class NotifyTask implements Runnable {
        public void run() {
            synchronized (obj) {
                System.out.println(Thread.currentThread() + " hold lock. notify...");
                obj.notifyAll();
                flag = true;//将flag设置为true
                SleepUtils.second(5);
            }
            synchronized (obj) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep...");
                SleepUtils.second(5);
            }
        }
    }
}

四、总结

wait和notify是Java中多线程同步的重要工具,在进行线程调度和任务协作时非常重要。使用wait和notify需要注意以下几点:

  1. wait和notify方法必须在同步块中调用。
  2. 在调用wait方法的时候,需要首先获取对象锁,否则会抛出IllegalMonitorStateException异常。
  3. 在调用wait方法时,线程会自动释放锁,进入等待状态,等待其他线程的通知。
  4. 在调用notify方法时,也需要首先获取对象锁,否则会抛出IllegalMonitorStateException异常。
  5. 在调用notify方法后,会唤醒一个处于等待状态的线程,并使其进入就绪状态。
  6. wait方法还可以设置等待的最大时间,如果在此时间内没有被唤醒,则线程会自动苏醒。