Java多线程同步问题——生产者消费者模型示例

原创雨点打透心脏的1/2处 2024-10-19 22:54 31阅读 0赞

在Java中，生产者消费者模型是一个经典的并发问题，通过共享资源（缓冲区）和锁机制实现线程间的协调。

以下是一个简单的生产者消费者模型示例：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Buffer {
    private int data;
    private Lock lock = new ReentrantLock();

public synchronized void produce() {
        // 生产数据
        if (data == 0) {
            System.out.println("Producer produced!");
            data = 1;
        } else {
            System.out.println("Producer already produced!");
        }
    }

public synchronized void consume() {
        // 消费数据
        if (data == 0) {
            System.out.println("Consumer consumed!");
            data = 2; // 表示缓冲区已满
        } else if (data == 1) {
            System.out.println("Consumer already consumed!");
        } else { // 数据已满
            System.out.println("Buffer is full!");
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();

Thread producerThread = new Thread(new Producer(buffer)));
        Thread consumerThread1 = new Thread(new Consumer1(buffer)));
        Thread consumerThread2 = new Thread(new Consumer2(buffer)));

producerThread.start();
        consumerThread1.start();
        consumerThread2.start();

// 等待所有线程完成
        try {
            producerThread.join();
            consumerThread1.join();
            consumerThread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

// 生产者线程，向缓冲区生产数据
    static class Producer implements Runnable {
        private Buffer buffer;

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

@Override
        public void run() {
            while (true) { // 无限循环
                buffer.produce(); // 生产数据

try {
                    // 等待一定时间，模拟生产过程中的延迟
                    Thread.sleep(1000); // 挂起1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

// 消费者线程，向缓冲区消费数据
    static class Consumer implements Runnable {
        private Buffer buffer;

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

@Override
        public void run() {
            while (true) { // 无限循环
                buffer.consume(); // 消费数据

try {
                    // 等待一定时间，模拟消费过程中的延迟
                    Thread.sleep(1000); // 挂起1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
```

在这个示例中，我们创建了一个Buffer类，它包含一个数据缓冲区和一个Lock对象。生产者线程（Producer）负责向缓冲区生产数据，而消费者线程（Consumer1, Consumer2）则负责从缓冲区消费数据。

在主线程中，我们启动了生产者线程、消费者线程1和消费者线程2，然后等待所有线程完成。