使用wait()函数实现生产者-消费者模式的线程同步

生产者-消费者模式是一种常见的线程同步模式，在多线程编程中非常常用。生产者线程负责生产数据，消费者线程负责消费数据，两者之间通过一个共享的缓冲区进行数据的交换。在这个模式中，生产者和消费者是独立运行的线程，为了确保生产者和消费者之间的协作，需要使用一些线程同步的机制。

wait()函数是Java中用于线程同步的方法之一，在使用wait()函数时，需要将其放在一个同步方法或同步块中，以确保线程的同步执行。当调用wait()函数后，线程会进入等待状态，并释放该同步锁，直到其他线程调用notify()或notifyAll()函数来唤醒该线程。

下面我将通过一个例子来说明如何使用wait()函数实现生产者-消费者模式的线程同步。

// 定义一个共享的缓冲区
class Buffer {
    private int data;
    private boolean available;

    public synchronized void produce(int newData) {
        while (available) { // 缓冲区已满，等待消费者消费
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        data = newData; // 生产数据
        available = true;
        System.out.println("生产者产生数据：" + newData);
        notify(); // 唤醒一个消费者线程
    }

    public synchronized int consume() {
        while (!available) { // 缓冲区为空，等待生产者生产
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        int consumeData = data; // 消费数据
        available = false;
        System.out.println("消费者消费数据：" + consumeData);
        notify(); // 唤醒一个生产者线程
        return consumeData;
    }
}

// 定义一个生产者线程
class Producer implements Runnable {
    private Buffer buffer;

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

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            buffer.produce(i);
        }
    }
}

// 定义一个消费者线程
class Consumer implements Runnable {
    private Buffer buffer;

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

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            buffer.consume();
        }
    }
}

// 在主线程中创建生产者和消费者线程，并启动它们
public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        Producer producer = new Producer(buffer);
        Consumer consumer = new Consumer(buffer);

        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);

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

在上面的例子中，定义了一个共享的缓冲区类Buffer，其中有一个成员变量data用来存储数据，一个成员变量available表示缓冲区是否可用。produce()方法用于生产数据，consume()方法用于消费数据。

在produce()方法中，如果缓冲区已满，生产者线程会调用wait()函数进入等待状态，并释放同步锁。当消费者消费了数据后，会调用notify()函数来唤醒其中一个等待的生产者线程。

在consume()方法中，如果缓冲区为空，消费者线程会调用wait()函数进入等待状态，并释放同步锁。当生产者生产了数据后，会调用notify()函数来唤醒其中一个等待的消费者线程。

在主线程中创建了一个Buffer实例对象和一个生产者线程和一个消费者线程，并启动它们。运行程序后，生产者线程会生产1到10的数据，消费者线程会消费这些数据，两者交替进行。通过使用wait()函数和notify()函数实现线程同步，确保了生产者和消费者之间的协作。