线程池调用及Future、Callable获得线程返回结果，并查看总耗时情况

主入口

package com.test;


import cn.hutool.core.date.DateUtil;

import java.util.ArrayList;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 测试案例：
 * 本次使用3个线程
 * 分配调用：CallableA（返回结果BaseResultA） ，CallableB（返回结果BaseResultB） ，CallableC（返回结果BaseResultC）
 */
public class MyExecutorService {

    private final int NUMBER = 3;

    public MyExecutorService() {
        long start = System.currentTimeMillis();

        // 创建容量为NUMBER的线程池。
        ExecutorService pool = Executors.newFixedThreadPool(NUMBER);
        ArrayList<Future<BaseResult>> futures = new ArrayList<Future<BaseResult>>();

        // 异步调用1
        CallableA callableA = new CallableA("测试A");
        Future<BaseResult> futureA= pool.submit(callableA);
        futures.add(futureA);
        // 异步调用2
        CallableB callableB = new CallableB("测试B");
        Future<BaseResult> futureB= pool.submit(callableB);
        futures.add(futureB);
        // 异步调用3
        CallableC callableC = new CallableC("测试C");
        Future<BaseResult> futureC= pool.submit(callableC);
        futures.add(futureC);

        System.out.println("获取结果中...");
        for (Future<BaseResult> f : futures) {
            try {
                BaseResult baseResult = f.get();
                if(baseResult instanceof BaseResultA){
                    //结果1
                    BaseResultA a=  (BaseResultA)baseResult;
                    System.out.println(a.getName());
                }else if(baseResult instanceof BaseResultB){
                    //结果2
                    BaseResultB b=  (BaseResultB)baseResult;
                    System.out.println(b.getMsg());
                }else if(baseResult instanceof BaseResultC){
                    //结果3
                    BaseResultC c=  (BaseResultC)baseResult;
                    System.out.println(c.getResult());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("得到结果.");

        // 关闭线程池。
        pool.shutdown();
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end -start)+" ms");

    }


    public static void main(String[] args) {
        String format = DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");
        System.out.println(format);

        new MyExecutorService();

        String format1 = DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");
        System.out.println(format1);
    }
}

CallableA线程执行器

package com.test;

import java.util.concurrent.Callable;

public class CallableA  implements Callable<BaseResult> {
    private String param;

    public CallableA(String param) {
        this.param = param;
    }

    @Override
    public BaseResult call() {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        BaseResultA  baseResult = new BaseResultA();
        baseResult.setName("CallableA:返回结果11111111-->"+param);
        return baseResult;
    }
}

CallableB线程执行器

package com.test;

import java.util.concurrent.Callable;

public class CallableB implements Callable<BaseResult> {
    private String param;

    public CallableB(String param) {
        this.param = param;
    }
    @Override
    public BaseResult call() {
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        BaseResultB  baseResult = new BaseResultB();
        baseResult.setMsg("CallableB:返回结果22222222--->"+param);
        return baseResult;
    }
}

## CallableC线程执行器

package com.test;

import java.util.concurrent.Callable;

public class CallableC implements Callable<BaseResult> {
    private String param;

    public CallableC(String param) {
        this.param = param;
    }
    @Override
    public BaseResult call() {
        try {
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        BaseResultC baseResult = new BaseResultC();
        baseResult.setResult("CallableC:返回结果33333---》"+param);
        return baseResult;
    }
}

结果基类BaseResult

package com.test;

public class BaseResult {
}

结果类BaseResultA

package com.test;

public class BaseResultA extends BaseResult{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

结果类BaseResultB

package com.test;

public class BaseResultB extends BaseResult{
    private String msg;

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

结果类BaseResultC

package com.test;

public class BaseResultC extends BaseResult{
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }
}

结果

2023-04-07 16:24:08.960
获取结果中...
CallableA:返回结果11111111-->测试A
CallableB:返回结果22222222--->测试B
CallableC:返回结果33333---》测试C
得到结果.
总耗时：5014 ms
2023-04-07 16:24:14.103

Process finished with exit code 0