Java互斥的"等待-通知"机制

Java互斥的”等待-通知”机制

在多线程编程中，线程之间的同步是一个非常重要的问题。Java提供了多种机制来实现线程同步，其中”等待-通知”机制是一种非常常用的方式。本文将详细介绍Java中的”等待-通知”机制，并通过示例代码展示其使用方法。

1. 什么是”等待-通知”机制？

“等待-通知”机制是一种线程间通信的方式，它允许一个线程在某个条件不满足时进入等待状态，直到另一个线程通知它条件已经满足。这种机制通常用于解决生产者-消费者问题、线程池管理等场景。

在Java中，”等待-通知”机制主要通过Object类的wait()、notify()和notifyAll()方法来实现。这些方法必须在同步代码块或同步方法中调用，因为它们依赖于对象的监视器锁。

2. wait()、notify()和notifyAll()方法

2.1 wait()方法

wait()方法使当前线程进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法，或者指定的超时时间到达。调用wait()方法时，当前线程会释放对象的监视器锁，允许其他线程获取锁并执行。

wait()方法有以下几个重载版本：

• wait()：使当前线程无限期等待，直到被通知。
• wait(long timeout)：使当前线程等待指定的毫秒数，或者直到被通知。
• wait(long timeout, int nanos)：使当前线程等待指定的毫秒数加纳秒数，或者直到被通知。

2.2 notify()方法

notify()方法唤醒在该对象上等待的单个线程。如果有多个线程在等待，JVM会选择一个线程进行唤醒。被唤醒的线程将尝试重新获取对象的监视器锁，并在获取锁后继续执行。

2.3 notifyAll()方法

notifyAll()方法唤醒在该对象上等待的所有线程。所有被唤醒的线程将竞争对象的监视器锁，获取锁的线程将继续执行。

3. 使用”等待-通知”机制的示例

下面通过一个简单的生产者-消费者问题来演示如何使用”等待-通知”机制。

3.1 生产者-消费者问题

生产者-消费者问题是一个经典的多线程同步问题。生产者线程负责生产数据并将其放入缓冲区，消费者线程负责从缓冲区中取出数据并进行处理。当缓冲区满时，生产者线程需要等待；当缓冲区空时，消费者线程需要等待。

3.2 代码实现

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

public class ProducerConsumer {
    private static final int BUFFER_SIZE = 5;
    private final Queue<Integer> buffer = new LinkedList<>();
    private final Object lock = new Object();

    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (lock) {
                while (buffer.size() == BUFFER_SIZE) {
                    lock.wait(); // 缓冲区满，生产者等待
                }
                System.out.println("生产者生产: " + value);
                buffer.add(value++);
                lock.notifyAll(); // 通知消费者
            }
            Thread.sleep(1000); // 模拟生产时间
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (lock) {
                while (buffer.isEmpty()) {
                    lock.wait(); // 缓冲区空，消费者等待
                }
                int value = buffer.poll();
                System.out.println("消费者消费: " + value);
                lock.notifyAll(); // 通知生产者
            }
            Thread.sleep(1000); // 模拟消费时间
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        Thread producerThread = new Thread(() -> {
            try {
                pc.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                pc.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

3.3 代码解析

• buffer是一个Queue，用于存储生产者生产的数据。
• lock是一个Object，用于同步生产者和消费者线程。
• produce()方法中，生产者线程在缓冲区满时调用lock.wait()进入等待状态，直到消费者线程消费数据后调用lock.notifyAll()唤醒它。
• consume()方法中，消费者线程在缓冲区空时调用lock.wait()进入等待状态，直到生产者线程生产数据后调用lock.notifyAll()唤醒它。
• notifyAll()方法用于唤醒所有等待的线程，确保生产者和消费者都能及时响应。

4. 注意事项

• wait()、notify()和notifyAll()方法必须在同步代码块或同步方法中调用，否则会抛出IllegalMonitorStateException异常。
• 使用wait()方法时，通常需要在循环中检查条件，以防止虚假唤醒（spurious wakeup）。
• notify()方法只会唤醒一个等待的线程，而notifyAll()方法会唤醒所有等待的线程。根据具体场景选择合适的唤醒方式。

5. 总结

Java中的”等待-通知”机制是一种强大的线程同步工具，能够有效地解决多线程环境下的资源竞争和线程间通信问题。通过合理使用wait()、notify()和notifyAll()方法，可以实现复杂的线程同步逻辑，确保程序的正确性和高效性。

在实际开发中，理解并掌握”等待-通知”机制的使用方法，对于编写高效、可靠的多线程程序至关重要。