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方法还可以设置等待的最大时间，如果在此时间内没有被唤醒，则线程会自动苏醒。