java线程池实现生产者消费者调用外部系统接口

原创

mob64ca12d2dee8 2024-10-07 03:55:41 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d2dee8的原创作品，请联系作者获取转载授权，否则将追究法律责任

通过 Java 线程池实现生产者-消费者模式调用外部系统接口

在现代软件开发中，生产者-消费者模式是一种常用的并发设计模式。通过它，我们可以优化线程的使用，处理大量的任务，特别是在需要调用外部系统接口时，线程池能够有效地管理系统资源。

整体流程

下面是整个实现过程的步骤示例：

步骤	描述
1	创建一个线程池
2	定义生产者类，该类负责生产任务并向阻塞队列中添加任务
3	定义消费者类，该类负责从阻塞队列中提取任务并执行
4	主方法中启动生产者和消费者
5	关闭线程池

每一步的详细实现

1. 创建一个线程池

首先，我们需要创建一个线程池。Java 提供了 Executors 类来创建线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    // 创建一个固定大小的线程池
    private static final ExecutorService executorService = Executors.newFixedThreadPool(5);
}

这段代码创建了一个固定大小为 5 的线程池，适合处理多个并发任务。

2. 定义生产者类

生产者类会将任务放入一个阻塞队列中，这样消费者可以从中取出任务。

import java.util.concurrent.BlockingQueue;

class Producer implements Runnable {
    private final BlockingQueue<String> queue;

    public Producer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                String task = "Task " + i;
                queue.put(task); // 向队列中添加任务
                System.out.println("Produced: " + task);
                Thread.sleep(100); // 模拟生产时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

run() 方法中，生产者会产生 10 个任务，并将它们放入队列中。queue.put(task) 使得生产者线程在队列满时等待。

3. 定义消费者类

消费者类从阻塞队列中提取任务并执行它们。

import java.util.concurrent.BlockingQueue;

class Consumer implements Runnable {
    private final BlockingQueue<String> queue;

    public Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                String task = queue.take(); // 从队列中提取任务
                System.out.println("Consumed: " + task);
                // 在这里调用外部系统接口，例如通过 HTTP 请求
                Thread.sleep(200); // 模拟处理时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在 run() 方法中，消费者会不断地从队列中提取任务，并假装调用外部系统接口处理它。

4. 主方法中启动生产者和消费者

在主方法中，我们需要将生产者和消费者实例化，并将其提交给线程池。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Main {
    private static final ExecutorService executorService = Executors.newFixedThreadPool(5);

    public static void main(String[] args) {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);

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

        executorService.submit(producer); // 提交生产者
        executorService.submit(consumer);  // 提交消费者

        // 适当维护线程池，确保在所有任务完成后关闭它
        executorService.shutdown();
    }
}

我们创建了一个容量为 5 的阻塞队列，并将生产者和消费者提交到线程池。

5. 关闭线程池

最后，确保在适当的时候关闭线程池以释放资源。

executorService.shutdown();

shutdown() 方法会平滑关闭线程池，拒绝新的任务加入并立即关闭现有活动任务。

状态图

下面是一个描述生产者与消费者之间状态的状态图：

stateDiagram
    [*] --> ProducerRunning
    ProducerRunning --> TaskProduced
    TaskProduced --> ConsumerWaiting
    ConsumerWaiting --> TaskConsumed
    TaskConsumed --> ProducerRunning

关系图

下面是生产者、消费者与任务之间的关系图：

erDiagram
    PRODUCER {
        String name
    }
    
    CONSUMER {
        String name
    }
    
    TASK {
        String taskDescription
    }

    PRODUCER ||--o{ TASK : produces
    CONSUMER ||--o{ TASK : consumes