使用通义灵码写了一个多线程工具类,通义灵码处于什么水平

本文涉及的产品
视觉智能开放平台,视频资源包5000点
NLP 自学习平台,3个模型定制额度 1个月
NLP自然语言处理_高级版,每接口累计50万次
简介: 当方法间无依赖需提升执行效率时,可采用并行执行。示例通过`MultiThreadTaskExecutor`类实现多线程并发,其中`executeParallelDynamicMethods`方法接收一系列`Callable`任务并返回所有任务的结果列表。测试显示,四个耗时方法并行执行仅需4秒,相较于串行执行的12秒显著提升效率。该代码展示了良好的多线程编程实践。

1、场景

有多个的方法,在串行执行的时候效率比较慢,在保证方法不相互依赖的情况下想要提高效率就需要并行执行

2、通义灵码开始工作

根据场景总结相关问题并咨询同义灵码,如:帮我写一个多个方法可并行执行并返回对应数据的工具类

3、通义灵码返回

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class MultiThreadTaskExecutor {
   
    private final ExecutorService executor;

    public MultiThreadTaskExecutor(int threadCount) {
   
        this.executor = Executors.newFixedThreadPool(threadCount);
    }

    /**
     * 并行执行多个方法并返回它们的结果。
     *
     * @param tasks 方法列表,每个方法都封装在Callable中
     * @return 一个Future数组,包含所有方法的返回结果
     */
    public <T> List<Future<T>> executeParallel(List<? extends Callable<T>> tasks) throws InterruptedException {
   
        return executor.invokeAll(tasks);
    }

    /**
     * 关闭executor服务
     */
    public void shutdown() {
   
        executor.shutdown();
    }

    /**
     * 执行一组动态方法(表示为Callable),并收集结果。
     * @param callables 可调用对象列表,每个对象代表一个动态方法
     * @param <T> 方法返回值的泛型
     * @return 包含所有方法执行结果的列表
     */
    public  <T> List<T> executeParallelDynamicMethods(List<Callable<T>> callables) {
   
        List<CompletableFuture<T>> futures = new ArrayList<>();
        for (Callable<T> callable : callables) {
   
            CompletableFuture<T> future = CompletableFuture.supplyAsync(() ->
                    {
   
                        try {
   
                            return callable.call();
                        } catch (Exception e) {
   
                            System.out.println("supplyAsync, 运行异常:" + e.getMessage());
                        }
                        return null;
                    }
                    , executor);
            futures.add(future);
        }

        // 等待所有任务完成
        CompletableFuture<Void> allDoneFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));

        try {
   
            allDoneFuture.get(); // 这里会阻塞直到所有任务完成
        } catch (InterruptedException | ExecutionException e) {
   
            System.out.println("executeParallelDynamicMethods, 运行异常:" + e.getMessage());
        }

        // 收集所有结果
        List<T> resultList = futures.stream().map(CompletableFuture::join).collect(Collectors.toList());
        // 关闭线程
        this.shutdown();
        return resultList;
    }

4、调用测试

import org.junit.Test;

import java.util.*;
import java.util.concurrent.Callable;

public class methodTest {
   
    public Integer timeConsumingMethod1() {
   
        long startTime= System.currentTimeMillis();
        try {
   
            Thread.sleep(3000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        long endTime= System.currentTimeMillis();
        return (int) ((endTime-startTime)/1000);
    }
    public Integer timeConsumingMethod2() {
   
        long startTime= System.currentTimeMillis();
        try {
   
            Thread.sleep(3000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        long endTime= System.currentTimeMillis();
        return (int) ((endTime-startTime)/1000);
    }
    public Integer timeConsumingMethod3() {
   
        long startTime= System.currentTimeMillis();
        try {
   
            Thread.sleep(2000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        long endTime= System.currentTimeMillis();
        return (int) ((endTime-startTime)/1000);
    }
    public  Integer timeConsumingMethod4() {
   
        long startTime= System.currentTimeMillis();
        try {
   
            Thread.sleep(4000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        long endTime= System.currentTimeMillis();
        return (int) ((endTime-startTime)/1000);
    }

    @Test
    public void parallelTest() {
   
        long startTime= System.currentTimeMillis();
        MultiThreadTaskExecutor executor = new MultiThreadTaskExecutor(4);
        List<Callable<Object>> callables = new ArrayList<>();
        callables.add(() -> timeConsumingMethod1());
        callables.add(() -> timeConsumingMethod2());
        callables.add(() -> timeConsumingMethod3());
        callables.add(() -> timeConsumingMethod4());
        List<Object> futures = executor.executeParallelDynamicMethods(callables);
        long endTime= System.currentTimeMillis();
        System.out.println("并行耗时:"+ ((endTime-startTime)/1000));
    }

    @Test
    public void serialTest() {
   
        long startTime= System.currentTimeMillis();
        timeConsumingMethod1();
        timeConsumingMethod2();
        timeConsumingMethod3();
        timeConsumingMethod4();
        long endTime= System.currentTimeMillis();
        System.out.println("串行耗时:"+ ((endTime-startTime)/1000));
    }

serialTest()运行结果

串行耗时:12


parallelTest()运行结果

并行耗时:4

5.总结

根据通义灵码提供的多线程方法测试发现,效率明显有很大提升,根据代码水平你们说一下目前的通义灵码处于什么水平呢?

相关文章
|
1月前
|
人工智能 自然语言处理 开发者
通义灵码助力开学第一课!百万开发者首选的 AI 编码工具通义灵码是如何炼成的?
我们非常高兴的宣布,通义灵码插件下载量突破400万啦!
1234 1
通义灵码助力开学第一课!百万开发者首选的 AI 编码工具通义灵码是如何炼成的?
|
2月前
|
设计模式 存储 安全
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
43 1
|
2月前
|
安全 Java 开发者
Java中的并发工具类与线程安全实现
Java中的并发工具类与线程安全实现
|
2月前
|
设计模式 缓存 安全
Java面试题:设计模式在并发编程中的创新应用,Java内存管理与多线程工具类的综合应用,Java并发工具包与并发框架的创新应用
Java面试题:设计模式在并发编程中的创新应用,Java内存管理与多线程工具类的综合应用,Java并发工具包与并发框架的创新应用
27 0
|
2月前
|
设计模式 存储 缓存
Java面试题:结合建造者模式与内存优化,设计一个可扩展的高性能对象创建框架?利用多线程工具类与并发框架,实现一个高并发的分布式任务调度系统?设计一个高性能的实时事件通知系统
Java面试题:结合建造者模式与内存优化,设计一个可扩展的高性能对象创建框架?利用多线程工具类与并发框架,实现一个高并发的分布式任务调度系统?设计一个高性能的实时事件通知系统
42 0
|
2月前
|
设计模式 并行计算 安全
Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
37 0
|
2月前
|
设计模式 安全 NoSQL
Java面试题:结合单例模式与Java内存管理,设计一个线程安全的单例类?分析Java多线程工具类ExecutorService与Java并发工具包中的工具类,设计一个Java并发框架的分布式锁实现
Java面试题:结合单例模式与Java内存管理,设计一个线程安全的单例类?分析Java多线程工具类ExecutorService与Java并发工具包中的工具类,设计一个Java并发框架的分布式锁实现
40 0
|
2月前
|
设计模式 存储 缓存
Java面试题:结合单例模式与Java内存模型,设计一个线程安全的单例类?使用内存屏障与Java并发工具类,实现一个高效的并发缓存系统?结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
Java面试题:结合单例模式与Java内存模型,设计一个线程安全的单例类?使用内存屏障与Java并发工具类,实现一个高效的并发缓存系统?结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
25 0
|
2月前
|
监控 Java
Java面试题:Java内存、多线程与并发工具包的深度探索,Java内存管理策略及其优化技巧,Java多线程并发控制的工具类与机制,Java并发工具包在实际项目中的应用
Java面试题:Java内存、多线程与并发工具包的深度探索,Java内存管理策略及其优化技巧,Java多线程并发控制的工具类与机制,Java并发工具包在实际项目中的应用
26 0
|
2月前
|
SQL 人工智能 前端开发
若依修改01-通义灵码 AI智能编码,从这里开始,搭建,设计,编码,部署,使用AI辅助设计,通义千问把AI辅助设计放到快捷链接当中,vscode可以嵌入通义灵码,必须解决idea+vscode+通义灵
若依修改01-通义灵码 AI智能编码,从这里开始,搭建,设计,编码,部署,使用AI辅助设计,通义千问把AI辅助设计放到快捷链接当中,vscode可以嵌入通义灵码,必须解决idea+vscode+通义灵