多线程异步执行任务并回收结果

创建线程池：

package com.siact.dataBoard.base;


import com.siact.dataBoard.utils.UnitConversion;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author tuyj
 * @version 1.0
 * @date 2021/3/1 0001 10:19
 */
@Slf4j
@Component
public class DataBoardThreadPoolExecutor {

    private static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 5;

    private static final int MAX_POOL_SIZE = 1000;

    private static final Long KEEP_ALIVE_TIME = 10L;

    private static final int QUEUE_CAPACITY = 100;

    public static ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        threadPoolStatus(executor, "任务");
        return executor;
    }

    public static void threadPoolStatus(ThreadPoolExecutor executor, String name) {
        ArrayBlockingQueue queue = (ArrayBlockingQueue) executor.getQueue();
        log.info(Thread.currentThread().getName() + "-" + name + "-:" +
                "核心线程数：" + executor.getCorePoolSize() +
                "活动线程数：" + executor.getActiveCount() +
                "最大线程数：" + executor.getMaximumPoolSize() +
                "线程池活跃度：" + UnitConversion.div(Double.parseDouble(executor.getActiveCount() + ""), Double.parseDouble(executor.getMaximumPoolSize() + "")) +
                "任务完成数：" + executor.getCompletedTaskCount() +
                "队列大小：" + (queue.size() + queue.remainingCapacity()) +
                "当前排队线程数：" + queue.size() +
                "队列剩余大小：" + queue.remainingCapacity() +
                "队列使用度：" + UnitConversion.div(Double.parseDouble(queue.size() + ""), Double.parseDouble(queue.size() + queue.remainingCapacity() + "")));
    }
}

引用：

            ThreadPoolExecutor exec = DataBoardThreadPoolExecutor.threadPoolExecutor();
            List<Future<Map<String, Integer>>> futureList = new ArrayList<>();
            equalInterval.forEach(time -> {
                Runnable task = new Runnable() {
                    @Override
                    public void run() {
                        futureList.add(asyncTaskService.getTdnDataByAsnc(countSql, databaseName, tableName, username, password, time, url));
                    }
                };
                exec.submit(task);
            });
            exec.shutdown();
            exec.awaitTermination(1, TimeUnit.HOURS);
            Map<String, Integer> collectMap = collectData(futureList);

使用future并做相应数据操作：

    /**
     * 收集future并处理数据
     *
     * @param futureList
     * @return
     */
    private Map<String, Integer> collectData(List<Future<Map<String, Integer>>> futureList) {
        Map<String, Integer> map = new HashMap<>();
        while (futureList.size() > 0) {
            for (int i = 0; i < futureList.size(); i++) {
                Future<Map<String, Integer>> future = futureList.get(i);
                try {
                    if (future != null && future.isDone()) {
                        Map<String, Integer> stringIntegerMap = future.get();
                        map.putAll(stringIntegerMap);
                        futureList.remove(future);
                    }
                } catch (Exception e) {
                    log.error("从future获取值出错");
                }
            }
        }
        try {
            Thread.sleep(50L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return map;
    }