JAVA多线程带返回值进行拼接返回数据

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量3.5k 收藏 35
点赞数 7
分类专栏： 多线程 带返回值 文章标签： java ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38647584/article/details/128289301
版权

多线程循环处理业务，并合并返回结果

最近在做项目，外部接口调用本系统，发送过来2000+的数据需要当前系统处理业务，单线程处理耗时半小时左右，执行很慢，对方系统要求加快处理速度，所以想到了应用多线程的方式，处理完并将结果返回给调用系统，我这里分为两步，首先将集合每100个为一组分开，然后进行多线程处理，100条为一个处理

通过百度获取到了以下信息
可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

1、继承Thread类实现多线程

继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}
在合适的地方启动线程如下：
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

2、实现Runnable接口方式实现多线程

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {
　　if (target != null) {
　　 target.run();
　　}
}

3、使用ExecutorService、Callable、Future实现有返回结果的多线程

ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问https://blog.csdn.net/jokeMqc/article/details/114063642，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：
下面这段代码可以修改直接使用

package com.pmp;

import com.pmp.project.webservice.domain.PlmResult.EsbResultPlm;

import java.util.concurrent.*;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;

/**
 * 有返回值的线程
 */
@SuppressWarnings("unchecked")
public class testThread {

    public static void main(String[] args) throws ExecutionException,
            InterruptedException {
        System.out.println("----程序开始运行----");
        Date date1 = new Date();
        /*给他个线程数*/
        int taskSize = 5;
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);
        // 创建多个有返回值的任务
        List<Future> list = new ArrayList<Future>();
        /*循环这个线程数的长度*/
        for (int i = 0; i < taskSize; i++) {
            /*这里的MyCallable是给你具体的业务那块传参数，你可以看下taskNum,在下面是有定义的
            * 这个MyCallable你就当是你要调用的业务方法，需要传什么参数，返回值不用改。
            * Callable c = new MyCallable(i + " ");这一句还并未真正执行这个方法，当作是初始化赋值
            * Future f =pool.submit(c);相当于是真正执行了 返回值是Future对象，这个不用改固定写法
            *   list.add(f); // 把结果放到上面定义的List中
            * */
            Callable c = new MyCallable(i + " ");
            // 执行任务并获取Future对象
            Future f = pool.submit(c);
            // System.out.println(">>>" + f.get().toString());
            list.add(f);
        }
        // 关闭线程池
        pool.shutdown();

        // 获取所有并发任务的运行结果
        for (Future f : list) {
            // 从Future对象上获取任务的返回值，并输出到控制台
            /*
            * Object o = f.get() 是对应返回的内容返回对象的Object，你可以指定返回对象，进行强转
            * */
            Object o = f.get();
            // EsbResultPlm esbResultPlm1 = (EsbResultPlm) f.get(); 这是强转的例子，更具自己的业务进行修改
            EsbResultPlm esbResultPlm1 = (EsbResultPlm) f.get();
            System.out.println(">>>" + f.get().toString());
        }

        Date date2 = new Date();
        System.out.println("----程序结束运行----，程序运行时间【"
                + (date2.getTime() - date1.getTime()) + "毫秒】");
    }
}

class MyCallable implements Callable<Object> {
    // taskNum自定义的属性
    private String taskNum;

    MyCallable(String taskNum) {
        this.taskNum = taskNum;
    }

    /*返回值可以是自定义的 Object*/
    public Object call() throws Exception {
        /*这块代码可以自由发挥，具体你想处理什么业务都可以写在这里，并且返回值也可以自定义*/
        System.out.println(">>>" + taskNum + "任务启动");
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum + "任务终止");
        return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
    }
}

展示我的业务代码可能会对你有所帮助，我是根据上面代码改的

public EsbResultPlm plmInitiateTargetPriceTask(plmTargetPrice plmTargetPrice) throws Exception {

        JSONObject jsonObject = JSONObject.parseObject(plmTargetPrice.getJsonForm());
        //baseInfo
        JSONObject baseInfo = jsonObject.getJSONObject("baseInfo");
        //partsInfo
        JSONArray partsInfoArray = jsonObject.getJSONArray("partsInfo");
        List<PlmTargeTask> plmTargeTaskList = partsInfoArray.toJavaList(PlmTargeTask.class);
        //将集合以200条一组进行分割
            /**
         * 分割LIST的POM配置
         *    <!--拆分List的工具类-->
         *         <dependency>
         *             <groupId>com.google.guava</groupId>
         *             <artifactId>guava</artifactId>
         *             <version>23.0</version>
         *         </dependency>
         */
        List<List<PlmTargeTask>> partition = Lists.partition(plmTargeTaskList, 200);
        logger.info("<<<----开始接收PLM发起目标价任务信息---->>>" + plmTargetPrice.getJsonForm());
        EsbResultPlm esbResultPlm = new EsbResultPlm();
        List<ResultPlmDetail> retList = new ArrayList<>();
        ExecutorService threadPool = Executors.newCachedThreadPool();

        int taskSize = partition.size();
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);
        // 创建多个有返回值的任务
        List<Future> list = new ArrayList<Future>();
        for (List<PlmTargeTask> plmTargeTasks : partition) {
            Callable c = new MyCallable(baseInfo, plmTargeTasks);
            // 执行任务并获取Future对象
            Future f = pool.submit(c);
            // System.out.println(">>>" + f.get().toString());
            list.add(f);
        }
        // 关闭线程池
        pool.shutdown();
        int i = 0;
        // 获取所有并发任务的运行结果
        for (Future f : list) {
            // 从Future对象上获取任务的返回值，并输出到控制台
            System.out.println("结果");
            EsbResultPlm esbResultPlm1 = (EsbResultPlm) f.get();
            if (Optional.ofNullable(esbResultPlm1).isPresent() &&
                    null != esbResultPlm1.getL_RET_STATUS()
                    && esbResultPlm1.getL_RET_STATUS().equals("E")) {
                esbResultPlm.setL_RET_STATUS(esbResultPlm1.getL_RET_STATUS());
                esbResultPlm.setL_RET_MESSAGE("PLM系统调用目标价任务发起接口成功，但存在发布失败任务，请查看明细！");
            } else if (Optional.ofNullable(esbResultPlm1).isPresent() &&
                    null != esbResultPlm1.getL_RET_STATUS() &&
                    esbResultPlm1.getL_RET_STATUS().equals("S")) {
                esbResultPlm.setL_RET_STATUS(EsbResult.RET_STATUS_SUCCESS);
                esbResultPlm.setL_RET_MESSAGE("PLM系统调用目标价任务发起接口成功！");
            }
            if (Optional.ofNullable(esbResultPlm1).isPresent() && null != esbResultPlm1.getList()) {
                retList.addAll(esbResultPlm1.getList());
                System.out.println("循环了多少次：" + ++i);
            }
            System.out.println(">>>" + f.get().toString());
        }

        Date date2 = new Date();
        System.out.println("----程序结束运行----，程序运行时间【毫秒】");
        esbResultPlm.setList(retList);
        return esbResultPlm;
    }
  /*多线程*/
    class MyCallable implements Callable<Object> {
    //自定义的字段，你就当你的方法传什么就定义什么就好了
        private List<PlmTargeTask> partsInfoArray;
        private JSONObject baseInfo;
		// MyCallable得在这个方法这里传入你定义的内容，这样你上面调用就会对应上了
        MyCallable(JSONObject baseInfo, List<PlmTargeTask> partsInfoArray) {
            this.partsInfoArray = partsInfoArray;
            this.baseInfo = baseInfo;
        }

        public EsbResultPlm call() throws Exception {
            Date dateTmp1 = new Date();
            Thread.sleep(1000);
            Date dateTmp2 = new Date();
            long time = dateTmp2.getTime() - dateTmp1.getTime();
            
            // 调用业务代码
            EsbResultPlm esbResultPlm = this.launchTargetPriceProcess(baseInfo, partsInfoArray);

            System.out.println(">>>" + "任务终止");
            return esbResultPlm;

        }

        public EsbResultPlm launchTargetPriceProcess(JSONObject baseInfo, List<PlmTargeTask> partsInfoArray) {
            EsbResultPlm esbResultPlm = new EsbResultPlm();
            // 这块是你的业务处理代码，随意发挥
            return esbResultPlm;
        }
    }

下面是最终的返回内容和请求内容，请参考
在这里插入图片描述

weixin_38647584
关注
  • 7
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java 利用多线程实现文件的分片下载
01-15
特别说明： Main方法是运行开始的方法，里面StopWatch是测速工具类，如果要想使用请导入相关maven坐标，不想使用直接删除即可。 内容概要： 这是随手写的一个利用线程池下载文件的小玩具，如果刚学完线程池不知道怎么使用的，可以拿来借鉴一下，互相学习。里面或许有些代码不太合理，但是作为练手项目还是可以的。 适用人群： 刚学完多线程和线程池，以及线程爱好者。 使用场景及目标： 大文件的快速下载，经测试在100M带宽的网络下，下载一个40M的文件，不超过两秒钟，当然还得根据自己电脑的配置来讲。 其他说明： 文件如果特别小，而自己网络又非常好的情况下，不建议使用线程池进行下载，因为线程任务的创建也会浪费一些时间和性能！因为写这个程序是为了更快的下载一些4K壁纸，所以传入的url只能是直链，当然 可以根据自己的能力进行改动。里面很多地方我都有注释说明，阅读起来不会很难。当然，希望道友可以指出代码的不足之处，让我们共同进步。毕竟分享是一个过程，能力的锻炼才是我们真正追求的结果！
java多线程编程之从线程返回数据的两种方法
09-04
从线程中返回数据和向线程传递数据类似。也可以通过类成员以及回调函数来返回数据。但类成员在返回数据和传递数据时有一些区别，下面让我们来看看它们区别在哪
java多线程返回值使用示例(callable与futuretask)
09-04
主要介绍了多线程返回值使用示例(callable与futuretask),需要的朋友可以参考下
Java多线程请求http接口并整合响应数据后返回
weixin_49809649的博客
07-08 1139
CountDownLatch是一个同步工具类，它通过一个计数器来实现的,初始值为线程的数量。每当一个线程完成了自己的任务,可以通过它的countDown()方法使计数器的值减1。当计数器到达0时,表示所有的线程都已执行完毕,然后在等待的线程就可以恢复执行任务。该第三方get接口能拼的param数量有限，因此需要分批多次请求，同步的话性能太差，所以开多个线程同时请求，等待所有线程都结束后，把获取到的数据返回。实现一个接口，接口内部请求第三方http接口获取数据后返回；
有返回值的多线程：Callable与Future、FutureTask
qq_33617861的博客
08-17 345
有返回值的多线程：Callable与Future、FutureTask Callable Callable是一个泛型接口，只实现了一个call()方法，这个跟Runnable类似，但是call()方法返回了一个传入的泛型结果，并且该方法是会抛出异常的 public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @r
Java线程：新特征-有返回值的线程
weixin_34146805的博客
11-04 126
Java线程：新特征-有返回值的线程   在Java5之前，线程是没有返回值的，常常为了“有”返回值，破费周折，而且代码很不好写。或者干脆绕过这道坎，走别的路了。   现在Java终于有可返回值的任务（也可以叫做线程）了。   可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。   执行Callable任务后，可以获取一个Future的对象...
Java多线程-新特性-有返回值的线程
kuyuyingzi的专栏
06-25 109
Java多线程-新特性-有返回值的线程 在Java5之前，线程是没有返回值的，常常为了“有”返回值，破费周折，而且代码很不好写。或者干脆绕过这道坎，走别的路了。 现在Java终于有可返回值的任务（也可以叫做线程）了。可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。 执行Callable任务后，可以获取一个Future的对象，在该对象上调用get...
java 多线程 返回值 Callable
10-12 141
package cn; import java.util.concurrent.*; import java.util.Date; import java.util.List; import java.util.ArrayList; /** * * Java线程：有返回值的线程 * @author wb_qiuquan.ying */ @SuppressWarnings("...
java并发（二十四）多线程结果组装
08-05
1.0 博文链接：https://phl.iteye.com/blog/2035708
Java多线程实现异步调用实例
09-18
Java多线程实现异步调用实例。运行Main可以看到结果。main是主线程，另有A,B,C三个线程用不同的时间跑完。
Linux多线程编程-线程函数返回值(返回复杂数据类型)
01-06
引言 通过几个实验练习，学习线程之间连接的具体实现。下面列举了两个例子，一个是子线程返回简单数据类型；另一个是子线程返回复杂数据类型。 实现代码 子线程返回复杂数据类型 #include #include #include #include struct member { int a; char *b; }; void *create(void *arg) { struct member *temp = (struct member*)malloc(sizeof(struct member)); temp->a = 2; temp->b = Hello
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。 2.数据批量导出。 3任务数据异步执行。 4.多线程请求第三方接口限流。
JQuery异步获取返回值中文乱码的解决方法
12-03
用jqgrid异步获取列表值，遇到个问题，服务器端从数据库取到的数据没有出现中文乱码问题（日志打出来是没有乱码的），但是异步传到客户的时候却出现了乱码。 服务器端已经编码过了（UTF-8编码）。开始一直怀疑是客户端的问题，比如客户端和服务器端编码不一致啊，也怀疑是不是jqGrid工具函数中少配了 contentType: “application/x-www-form-urlencoded; charset=utf-8”,   等等问题。 结果都不是，纠结了几个小时，后来经过大牛的提醒发现，原来代码还是出在服务器端，疏忽了。 @RequestMapping(value = "/searchU
C++多线程获取返回值方法详解
08-19
主要介绍了C++多线程获取返回值方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详解Java多线程处理List数据
08-26
主要介绍了Java多线程处理List数据，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 745
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 824
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Java 怎么获取多线程的返回值
06-12
在 Java 中，获取多线程的返回值可以通过以下几种方式： 1. 使用 Callable 和 Future 接口。Callable 接口定义了 call() 方法用于返回结果，Future 接口用于获取异步计算结果。示例代码如下： ``` import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class ThreadTest { public static void main(String[] args) throws ExecutionException, InterruptedException { Callable<Integer> callable = new Callable<Integer>() { @Override public Integer call() throws Exception { // 在这里编写耗时的业务逻辑 return 100; } }; FutureTask<Integer> futureTask = new FutureTask<>(callable); Thread thread = new Thread(futureTask); thread.start(); Integer result = futureTask.get(); // 获取异步计算结果 System.out.println(result); } } ``` 2. 使用 Runnable 接口和共享变量。在多线程环境下，可以使用共享变量来传递和获取线程的返回结果。示例代码如下： ``` public class ThreadTest { static int result = 0; public static void main(String[] args) throws InterruptedException { Runnable runnable = new Runnable() { @Override public void run() { // 在这里编写耗时的业务逻辑 result = 100; } }; Thread thread = new Thread(runnable); thread.start(); thread.join(); System.out.println(result); } } ``` 以上两种方式都可以获取多线程的返回值，具体使用哪种方式取决于业务需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值