Java多线程之ExecutorService.invokeAll()

1.ThreadExecutorConfig线程池的配置

package com.fn.config.threads;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.*;

@Configuration
@EnableAsync
public class ThreadExecutorConfig implements AsyncConfigurer
{

    /**
     * 线程池维护线程的最少数量
     */
    private final static int CORE_POOL_SIZE=2;

    /**
     * 线程池维护线程的最大数量
     */
    private final static int MAX_POOL_SIZE=10;
    /**
     * 缓存队列
     */
    private final static int QUEUE_NUMBER=99999;

    /**
     * 线程标识
     */
    private final static String THREAD_NAME="asyncExecutor-";

    /**
     * 允许的空闲时间
     */
    private final static int KEEP_ALIVE_SECONDS=30;

    /**
     * 使用方法： @Async("asyncExecutor") 标注到方法上
     * @return
     */
    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        // ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();
        // 获取Java虚拟机的可用的处理器数，最佳线程个数，处理器数*2。根据实际情况调整
        int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;
        executor.setCorePoolSize(CORE_POOL_SIZE);
        executor.setMaxPoolSize(curSystemThreads);
        executor.setQueueCapacity(QUEUE_NUMBER);
        executor.setThreadNamePrefix(THREAD_NAME);
        /**
         * 对拒绝task的处理策略
         rejection-policy：当pool已经达到max size的时候，如何处理新任务
         CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);
        executor.initialize();
        return executor;
    }

	/**
	* 获取线程池的方法
	*/
    @Bean
    public ExecutorService getThreadPool(){
        int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;
        return Executors.newFixedThreadPool(curSystemThreads);
    }

}

2.VisiableThreadPoolTaskExecutor

package com.fn.config.threads;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;

import java.util.concurrent.Future;

import java.util.concurrent.ThreadPoolExecutor;

/**
 * 名称： VisiableThreadPoolTaskExecutor
 * 日期： 2020-10-27 4:53 下午
 * 描述：为了查看更多线程信息，实现VisiableThreadPoolTaskExecutor  继承ThreadPoolTaskExecutor
 **/
public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private static final Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);

    private void showThreadPoolInfo(String prefix) {

        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        if (null == threadPoolExecutor) {

            return;

        }

        logger.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",

                this.getThreadNamePrefix(),

                prefix,

                threadPoolExecutor.getTaskCount(),

                threadPoolExecutor.getCompletedTaskCount(),

                threadPoolExecutor.getActiveCount(),

                threadPoolExecutor.getQueue().size());

    }

    @Override

    public void execute(Runnable task) {

        showThreadPoolInfo("1. do execute");

        super.execute(task);

    }

    @Override

    public void execute(Runnable task, long startTimeout) {

        showThreadPoolInfo("2. do execute");

        super.execute(task, startTimeout);

    }

    @Override

    public Future<?> submit(Runnable task) {

        showThreadPoolInfo("1. do submit");

        return super.submit(task);

    }

    @Override

    public <T> Future<T> submit(Callable<T> task) {

        showThreadPoolInfo("2. do submit");

        return super.submit(task);

    }

    @Override

    public ListenableFuture<?> submitListenable(Runnable task) {

        showThreadPoolInfo("1. do submitListenable");

        return super.submitListenable(task);

    }

    @Override

    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {

        showThreadPoolInfo("2. do submitListenable");

        return super.submitListenable(task);

    }

}

3.使用线程进行批量操作

    public void bachSave(List<FireControlTeamAndEquipmentSaveDto> list) {
        Set<Callable<String>> callables = new HashSet<>();
        for (FireControlTeamAndEquipmentSaveDto dto : list) {
            callables.add(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    contingencyReserveFeignClient.fireControlTeamSave(dto);
                    logger.info("success");
                    return "success";
                }
            });
        }
        try {
            executorService.invokeAll(callables);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("批量写入异常");
        }
    }