Java怎么使用wait或notify实现线程间通信

在Java中，线程间通信是多线程编程中的一个重要概念。为了实现线程间的协调与同步，Java提供了wait()和notify()方法。这两个方法都是Object类的一部分，因此所有Java对象都可以使用它们。本文将详细介绍如何使用wait()和notify()实现线程间通信，并通过示例代码帮助读者更好地理解这些概念。

1. 线程间通信的基本概念

在多线程环境中，线程之间可能需要共享数据或协调工作。为了实现这一点，线程之间需要进行通信。Java提供了多种机制来实现线程间通信，其中wait()和notify()是最常用的方法之一。

1.1 wait()方法

wait()方法使当前线程进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法。调用wait()方法时，当前线程会释放对象的锁，并进入等待队列。

1.2 notify()方法

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

1.3 notifyAll()方法

notifyAll()方法唤醒在该对象上等待的所有线程。所有被唤醒的线程将竞争对象的锁，只有一个线程能够成功获取锁并继续执行。

2. wait()和notify()的使用场景

wait()和notify()通常用于生产者-消费者模式中。在这种模式下，生产者线程生成数据并将其放入共享缓冲区，而消费者线程从缓冲区中取出数据进行处理。当缓冲区为空时，消费者线程需要等待生产者线程生成数据；当缓冲区满时，生产者线程需要等待消费者线程消费数据。

3. 使用wait()和notify()实现线程间通信

下面通过一个简单的生产者-消费者示例来演示如何使用wait()和notify()实现线程间通信。

3.1 共享缓冲区

首先，我们定义一个共享缓冲区类SharedBuffer，它包含一个List来存储数据，并提供了put()和take()方法来添加和取出数据。

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

public class SharedBuffer {
    private Queue<Integer> buffer = new LinkedList<>();
    private final int capacity;

    public SharedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(int value) throws InterruptedException {
        while (buffer.size() == capacity) {
            wait(); // 缓冲区已满，等待消费者消费
        }
        buffer.add(value);
        System.out.println("Produced: " + value);
        notifyAll(); // 通知消费者可以消费了
    }

    public synchronized int take() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait(); // 缓冲区为空，等待生产者生产
        }
        int value = buffer.poll();
        System.out.println("Consumed: " + value);
        notifyAll(); // 通知生产者可以生产了
        return value;
    }
}

3.2 生产者线程

接下来，我们定义一个生产者线程类Producer，它不断地向共享缓冲区中添加数据。

public class Producer implements Runnable {
    private SharedBuffer buffer;

    public Producer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                buffer.put(i);
                Thread.sleep(100); // 模拟生产时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3.3 消费者线程

然后，我们定义一个消费者线程类Consumer，它不断地从共享缓冲区中取出数据。

public class Consumer implements Runnable {
    private SharedBuffer buffer;

    public Consumer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                buffer.take();
                Thread.sleep(150); // 模拟消费时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3.4 测试代码

最后，我们编写一个测试类ProducerConsumerTest来启动生产者和消费者线程。

public class ProducerConsumerTest {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer(5);

        Thread producerThread = new Thread(new Producer(buffer));
        Thread consumerThread = new Thread(new Consumer(buffer));

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

3.5 运行结果

运行上述代码后，输出结果如下：

Produced: 0
Consumed: 0
Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5
Produced: 6
Consumed: 6
Produced: 7
Consumed: 7
Produced: 8
Consumed: 8
Produced: 9
Consumed: 9

从输出结果可以看出，生产者和消费者线程通过wait()和notify()实现了线程间的协调与同步。

4. wait()和notify()的注意事项

在使用wait()和notify()时，需要注意以下几点：

4.1 必须在同步块中使用

wait()和notify()必须在同步块或同步方法中使用，否则会抛出IllegalMonitorStateException异常。这是因为wait()和notify()依赖于对象的锁机制。

4.2 使用while循环检查条件

在调用wait()之前，通常需要使用while循环来检查条件。这是因为线程被唤醒后，条件可能仍然不满足（例如，多个线程在等待同一个条件），因此需要再次检查条件。

4.3 避免死锁

在使用wait()和notify()时，需要小心避免死锁。死锁通常发生在多个线程相互等待对方释放锁的情况下。为了避免死锁，应确保线程以一致的顺序获取锁。

5. 使用notifyAll()的替代方案

在某些情况下，使用notifyAll()可能会导致性能问题，因为它会唤醒所有等待的线程，而实际上只有一个线程能够继续执行。为了避免这种情况，可以使用Condition类来实现更细粒度的线程控制。

5.1 Condition类

Condition类是java.util.concurrent.locks包的一部分，它提供了类似于wait()和notify()的功能，但支持多个条件队列。通过使用Condition，可以更精确地控制哪些线程被唤醒。

5.2 使用Condition实现生产者-消费者模式

下面是一个使用Condition实现的生产者-消费者示例。

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SharedBufferWithCondition {
    private Queue<Integer> buffer = new LinkedList<>();
    private final int capacity;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public SharedBufferWithCondition(int capacity) {
        this.capacity = capacity;
    }

    public void put(int value) throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == capacity) {
                notFull.await(); // 缓冲区已满，等待
            }
            buffer.add(value);
            System.out.println("Produced: " + value);
            notEmpty.signal(); // 通知消费者可以消费了
        } finally {
            lock.unlock();
        }
    }

    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.isEmpty()) {
                notEmpty.await(); // 缓冲区为空，等待
            }
            int value = buffer.poll();
            System.out.println("Consumed: " + value);
            notFull.signal(); // 通知生产者可以生产了
            return value;
        } finally {
            lock.unlock();
        }
    }
}

5.3 测试代码

public class ProducerConsumerWithConditionTest {
    public static void main(String[] args) {
        SharedBufferWithCondition buffer = new SharedBufferWithCondition(5);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.put(i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.take();
                    Thread.sleep(150);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

5.4 运行结果

运行上述代码后，输出结果与之前的示例类似，但使用了Condition类来实现更细粒度的线程控制。

6. 总结

wait()和notify()是Java中实现线程间通信的重要工具。通过合理地使用这两个方法，可以实现线程间的协调与同步，从而避免竞态条件和死锁等问题。在实际开发中，应根据具体需求选择合适的线程通信机制，并注意避免常见的陷阱和错误。

通过本文的介绍和示例代码，读者应该能够理解如何使用wait()和notify()实现线程间通信，并能够在实际项目中应用这些知识。希望本文对您有所帮助！