当前位置：首页 > news >正文

AI大模型编写多线程并发框架（六十一）：从零开始搭建框架

news 来源：原创 2024/9/19 8:53:09

系列文章目录

文章目录

系列文章目录
前言
- 一、项目背景
- 二、第一轮对话-让AI大模型理解我们的诉求
- 二、第二轮对话-优化任务处理方法和结果处理方法
- 三、参考文章

前言

在这个充满技术创新的时代，AI大模型正成为开发者们的新宠。它们可以帮助我们完成从简单的问答到复杂的编程任务，所以AI编程将会是未来的主流方向，利用AI大模型的能力，本文将介绍从零到一用AI大模型编写一个多线程并发框架。

一、项目背景

由于博主每次批量处理数据任务时，都需要去考虑线程池各种参数，例如考虑任务执行速率、任务监控、任务回调、异常处理等。由于每个需求的实际诉求不一样，所以数据处理任务的代替代码都一样，只有部分有差异，从而导致代码仓库里各种复制粘贴，
这不是博主想要的，于是，萌发了一个封装一个多线程组件框架的想法，只需要传入自定义任务等参数，其它东西都不需要关心。

使用示例如下：源码地址


// 创建一个MmcTaskExecutor实例，用于执行单次长耗时任务
// 下面是创建一个计算从1加到100的任务，总共100个任务，采用fork分治算法，阈值为10，总共任务为100 / 10 * 2 = 20个大任务，执行速率约为10/s
MmcTaskExecutor<Integer, Integer> mmcTaskExecutor = MmcTaskExecutor.<Integer, Integer>builder().taskSource(IntStream.rangeClosed(1, 100).boxed().collect(Collectors.toList())) // 设置任务源.taskProcessor(x -> x.stream().reduce(0, Integer::sum)) // 设置任务处理方法.taskMerger(Integer::sum) // 设置结果处理方法（可选）.threshold(10) // 设置任务处理阈值（可选）.taskName("mmcTaskExample") // 设置任务名称.rateLimiter(10, 20)  // 设置速率限制，容量为10，每秒产生令牌为20，休眠时间为10ms.forkJoinPoolConcurrency(4) // 设置ForkJoinPool的并发度为4.build();// 同步执行并打印结果        
System.out.println("result: " + mmcTaskExecutor.execute());// 任务执行过程监控
[mmcTaskExample] Tasks submitted. Total tasks: 100
[mmcTaskExample] Task started. Completed tasks: 14, remaining tasks: 86
[mmcTaskExample] Task started. Completed tasks: 14, remaining tasks: 86
[mmcTaskExample] Task started. Completed tasks: 20, remaining tasks: 80
[mmcTaskExample] Task started. Completed tasks: 26, remaining tasks: 74
[mmcTaskExample] Task started. Completed tasks: 33, remaining tasks: 67
[mmcTaskExample] Task started. Completed tasks: 40, remaining tasks: 60
[mmcTaskExample] Task started. Completed tasks: 46, remaining tasks: 54
[mmcTaskExample] Task started. Completed tasks: 52, remaining tasks: 48
[mmcTaskExample] Task started. Completed tasks: 58, remaining tasks: 42
[mmcTaskExample] Task started. Completed tasks: 64, remaining tasks: 36
[mmcTaskExample] Task started. Completed tasks: 70, remaining tasks: 30
[mmcTaskExample] Task started. Completed tasks: 76, remaining tasks: 24
[mmcTaskExample] Task started. Completed tasks: 82, remaining tasks: 18
[mmcTaskExample] Task started. Completed tasks: 88, remaining tasks: 12
[mmcTaskExample] Task started. Completed tasks: 94, remaining tasks: 6
[mmcTaskExample] Task started. Completed tasks: 100, remaining tasks: 0
[mmcTaskExample] Tasks completed. Elapsed time: 1107 ms 
result: 5050

二、第一轮对话-让AI大模型理解我们的诉求

1、首先告诉AI大模型我的想法和目的，让它充当编程专家，给出初始化代码。
在这里插入图片描述

2、下面是AI给的回复。

【首先，我们需要创建一个核心类MmcTask，它将实现RecursiveTask接口，并实现compute方法，用于执行真正的任务处理方法。】

import java.util.List;
import java.util.concurrent.RecursiveTask;public class MmcTask<T, R> extends RecursiveTask<R> {private List<T> taskSource;private MmcTaskHandler<T, R> taskHandler;private int threshold;private int start;private int end;public MmcTask(List<T> taskSource, MmcTaskHandler<T, R> taskHandler, int threshold, int start, int end) {this.taskSource = taskSource;this.taskHandler = taskHandler;this.threshold = threshold;this.start = start;this.end = end;}@Overrideprotected R compute() {// 当任务数量小于等于阈值时，执行真正的任务处理方法if (end - start <= threshold) {return taskHandler.handle(taskSource.subList(start, end));}// 将任务拆分为两部分，并递归执行int middle = (start + end) / 2;MmcTask<T, R> leftTask = new MmcTask<>(taskSource, taskHandler, threshold, start, middle);MmcTask<T, R> rightTask = new MmcTask<>(taskSource, taskHandler, threshold, middle, end);leftTask.fork();R rightResult = rightTask.compute();R leftResult = leftTask.join();// 合并两个任务的结果return taskHandler.merge(leftResult, rightResult);}
}

【接下来，我们需要创建一个MmcTaskHandler接口，用于处理任务并合并任务结果。】

public interface MmcTaskHandler<T, R> {R handle(List<T> taskSource);R merge(R leftResult, R rightResult);
}

【然后，我们创建一个MmcTaskExecutor类，用于构建任务容器并执行任务。】

import java.util.List;
import java.util.concurrent.ForkJoinPool;public class MmcTaskExecutor<T, R> {private List<T> taskSource;private MmcTaskHandler<T, R> taskHandler;private int threshold;private ForkJoinPool forkJoinPool;private MmcTaskExecutor(Builder<T, R> builder) {this.taskSource = builder.taskSource;this.taskHandler = builder.taskHandler;this.threshold = builder.threshold;this.forkJoinPool = builder.forkJoinPool;}public static <T, R> Builder<T, R> builder() {return new Builder<>();}public R execute() {MmcTask<T, R> mmcTask = new MmcTask<>(taskSource, taskHandler, threshold, 0, taskSource.size());return forkJoinPool.invoke(mmcTask);}public static class Builder<T, R> {private List<T> taskSource;private MmcTaskHandler<T, R> taskHandler;private int threshold = 10;private ForkJoinPool forkJoinPool = new ForkJoinPool();public Builder<T, R> taskSource(List<T> taskSource) {this.taskSource = taskSource;return this;}public Builder<T, R> taskHandler(MmcTaskHandler<T, R> taskHandler) {this.taskHandler = taskHandler;return this;}public Builder<T, R> threshold(int threshold) {this.threshold = threshold;return this;}public Builder<T, R> forkJoinPool(ForkJoinPool forkJoinPool) {this.forkJoinPool = forkJoinPool;return this;}public MmcTaskExecutor<T, R> build() {return new MmcTaskExecutor<>(this);}}
}

【最后，我们编写一个示例，计算从1加到100的结果。】

import java.util.ArrayList;
import java.util.List;public class MmcTaskExample {public static void main(String[] args) {List<Integer> taskSource = new ArrayList<>();for (int i = 1; i <= 100; i++) {taskSource.add(i);}MmcTaskHandler<Integer, Integer> taskHandler = new MmcTaskHandler<Integer, Integer>() {@Overridepublic Integer handle(List<Integer> taskSource) {int sum = 0;for (Integer num : taskSource) {sum += num;}return sum;}@Overridepublic Integer merge(Integer leftResult, Integer rightResult) {return leftResult + rightResult;}};MmcTaskExecutor<Integer, Integer> mmcTaskExecutor = MmcTaskExecutor.<Integer, Integer>builder().taskSource(taskSource).taskHandler(taskHandler).threshold(10).build();Integer result = mmcTaskExecutor.execute();System.out.println(result);  // 输出5050}
}

从AI大模型给出的代码来看，它基本能理解我们的意图，不过也存在一下问题：

我希望任务处理方法和结果处理方法可以分开传入，而AI给出的MmcTaskHandler是合并一起的；
我要求代码需要有注释，但AI实际上并没有给太多注释；

不过问题不大，我们可以通过多轮对话去优化。

二、第二轮对话-优化任务处理方法和结果处理方法

1、MmcTaskHandler应该要拆分，也就是MmcTaskExecutor.builder要支持传入真正处理任务的方法，也要支持传入merge结果的处理方法，因为有些任务可能是没有计算结果的，所以merge结果处理方法可以为空。在这里插入图片描述

2、下面是AI大模型给的回复。

【根据您的要求，我们可以将MmcTaskHandler拆分为两个接口：MmcTaskProcessor用于处理任务，MmcTaskMerger用于合并任务结果。同时，我们修改MmcTaskExecutor.Builder类以支持传入这两个接口。首先，我们创建一个MmcTaskProcessor接口。】

public interface MmcTaskProcessor<T, R> {R process(List<T> taskSource);
}

【接下来，我们创建一个MmcTaskMerger接口。】

public interface MmcTaskMerger<R> {R merge(R leftResult, R rightResult);
}

【然后，我们修改MmcTaskExecutor类。】

import java.util.List;
import java.util.concurrent.ForkJoinPool;public class MmcTaskExecutor<T, R> {private List<T> taskSource;private MmcTaskProcessor<T, R> taskProcessor;private MmcTaskMerger<R> taskMerger;private int threshold;private ForkJoinPool forkJoinPool;private MmcTaskExecutor(Builder<T, R> builder) {this.taskSource = builder.taskSource;this.taskProcessor = builder.taskProcessor;this.taskMerger = builder.taskMerger;this.threshold = builder.threshold;this.forkJoinPool = builder.forkJoinPool;}public static <T, R> Builder<T, R> builder() {return new Builder<>();}public R execute() {MmcTask<T, R> mmcTask = new MmcTask<>(taskSource, taskProcessor, taskMerger, threshold, 0, taskSource.size());return forkJoinPool.invoke(mmcTask);}public static class Builder<T, R> {private List<T> taskSource;private MmcTaskProcessor<T, R> taskProcessor;private MmcTaskMerger<R> taskMerger;private int threshold = 10;private ForkJoinPool forkJoinPool = new ForkJoinPool();public Builder<T, R> taskSource(List<T> taskSource) {this.taskSource = taskSource;return this;}public Builder<T, R> taskProcessor(MmcTaskProcessor<T, R> taskProcessor) {this.taskProcessor = taskProcessor;return this;}public Builder<T, R> taskMerger(MmcTaskMerger<R> taskMerger) {this.taskMerger = taskMerger;return this;}public Builder<T, R> threshold(int threshold) {this.threshold = threshold;return this;}public Builder<T, R> forkJoinPool(ForkJoinPool forkJoinPool) {this.forkJoinPool = forkJoinPool;return this;}public MmcTaskExecutor<T, R> build() {return new MmcTaskExecutor<>(this);}}
}

【最后，我们需要修改MmcTask类以适应这些更改。】

import java.util.List;
import java.util.concurrent.RecursiveTask;public class MmcTask<T, R> extends RecursiveTask<R> {private List<T> taskSource;private MmcTaskProcessor<T, R> taskProcessor;private MmcTaskMerger<R> taskMerger;private int threshold;private int start;private int end;public MmcTask(List<T> taskSource, MmcTaskProcessor<T, R> taskProcessor, MmcTaskMerger<R> taskMerger, int threshold, int start, int end) {this.taskSource = taskSource;this.taskProcessor = taskProcessor;this.taskMerger = taskMerger;this.threshold = threshold;this.start = start;this.end = end;}@Overrideprotected R compute() {if (end - start <= threshold) {return taskProcessor.process(taskSource.subList(start, end));}int middle = (start + end) / 2;MmcTask<T, R> leftTask = new MmcTask<>(taskSource, taskProcessor, taskMerger, threshold, start, middle);MmcTask<T, R> rightTask = new MmcTask<>(taskSource, taskProcessor, taskMerger, threshold, middle, end);leftTask.fork();R rightResult = rightTask.compute();R leftResult = leftTask.join();if (taskMerger != null) {return taskMerger.merge(leftResult, rightResult);} else {return null;}}
}

【计算1到100的最终实例代码。】

import java.util.ArrayList;
import java.util.List;public class MmcTaskExample {public static void main(String[] args) {List<Integer> taskSource = new ArrayList<>();for (int i = 1; i <= 100; i++) {taskSource.add(i);}MmcTaskProcessor<Integer, Integer> taskProcessor = new MmcTaskProcessor<Integer, Integer>() {@Overridepublic Integer process(List<Integer> taskSource) {int sum = 0;for (Integer num : taskSource) {sum += num;}return sum;}};MmcTaskMerger<Integer> taskMerger = new MmcTaskMerger<Integer>() {@Overridepublic Integer merge(Integer leftResult, Integer rightResult) {return leftResult + rightResult;}};MmcTaskExecutor<Integer, Integer> mmcTaskExecutor = MmcTaskExecutor.<Integer, Integer>builder().taskSource(taskSource).taskProcessor(taskProcessor).taskMerger(taskMerger).threshold(10).build();Integer result = mmcTaskExecutor.execute();System.out.println(result);  // 输出5050}
}