生产者消费者模式java

最新推荐文章于 2024-10-16 10:13:45 发布

好摩

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量40

点赞数

文章标签： java 开发语言

我整理的一些关于【CI】的项目学习资料（附讲解～～）和大家一起分享、学习一下：

https://d.51cto.com/bLN8S1

实现生产者-消费者模式的Java教程

引言

生产者-消费者模式是一种常用的多线程设计模式，它用于解决在多线程环境中如何协调不同线程之间的共享资源访问问题。简单来说，生产者负责生成数据，而消费者负责处理数据。两者通过一个线程安全的缓冲区进行协作，确保在并发访问时的安全和有效性。

本文将带您一步一步实现这个模式，包括流程设计、代码实现和详细解读。

整体流程

在实现生产者消费者模式时，我们需要一个生产者线程、一个消费者线程，以及一个共享的缓冲区。以下是实现的步骤：

步骤	描述
1	定义共享缓冲区
2	创建生产者类
3	创建消费者类
4	实现生产者线程和消费者线程的协作
5	测试生产者和消费者

步骤详解

接下来我们将逐步实现上述流程，每个步骤将附上代码示例并进行详细说明。

步骤 1：定义共享缓冲区

首先，我们需要一个共享缓冲区来存放生产者生产的产品。

import java.util.LinkedList;

// 定义一个缓冲区，缓冲区使用链表来实现
class SharedBuffer {
    private LinkedList<Integer> buffer = new LinkedList<>();
    private int capacity; // 缓冲区的最大容量

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

    // 生产者生产产品的方法
    public synchronized void produce(int value) throws InterruptedException {
        while (buffer.size() == capacity) {
            wait(); // 如果缓冲区已满，等待
        }
        buffer.add(value); // 添加产品到缓冲区
        System.out.println("Produced: " + value);
        notifyAll(); // 唤醒消费者
    }

    // 消费者消费产品的方法
    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait(); // 如果缓冲区为空，等待
        }
        int value = buffer.removeFirst(); // 从缓冲区取出产品
        System.out.println("Consumed: " + value);
        notifyAll(); // 唤醒生产者
        return value;
    }
}

解释：

我们定义了一个SharedBuffer类，其中包含一个链表来存放缓冲区的数据。
produce方法用于生产者添加新产品，当缓冲区达到最大容量是会调用wait()方法使生产者线程等待。
consume方法用于消费者获取产品，当缓冲区为空时会调用wait()方法使消费者线程等待。

步骤 2：创建生产者类

接下来，我们需要定义一个生产者类。

class Producer extends Thread {
    private SharedBuffer buffer;

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

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

解释：

Producer类继承自Thread，在run方法中调用缓冲区的produce方法实现生产功能。
使用Thread.sleep(100)模拟生产的时间延迟。

步骤 3：创建消费者类

接下来，我们需要定义一个消费者类。

class Consumer extends Thread {
    private SharedBuffer buffer;

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

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

解释：

Consumer类同样继承自Thread，在run方法中调用缓冲区的consume方法实现消费功能。
使用Thread.sleep(150)模拟消费的时间延迟。

步骤 4：实现生产者线程和消费者线程的协作

现在我们将把生产者和消费者放在一起，创建它们的实例并启动。

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer(5); // 创建一个最大容量为5的缓冲区

        Producer producer = new Producer(buffer);
        Consumer consumer = new Consumer(buffer);

        producer.start(); // 启动生产者线程
        consumer.start(); // 启动消费者线程

        try {
            producer.join(); // 等待生产者线程完成
            consumer.join(); // 等待消费者线程完成
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 处理异常
        }
    }
}