Java springboot主线程拆分多子线程任务，完成后继续主线程

        开发中遇到了一个问题，我们数据库里的数据是加密过的，读取、计算等等操作，都会有对原始数据进行加解密的操作。

        问题是单次操作数据量有几千条，如果是单线程进行解密的话，时间实在是有点慢。这是不能忍受的，所以，我们需要对其进行并发加解密。

        我的具体思路是这样的，因为加解密的动作，其实是对一个长List进行单项的加解密的动作。

        可以将这个长List进行分段区分，生成多个子线程的任务，每个子线程只执行长List中的一段区间内的加解密，多个子线程都完成任务后，这个总的任务就算是完成了。

思路：

        1、拆分子任务，让其可以一个一个完成。

        2、造子线程作为载体，运行子任务

        一、拆子任务，因为我的子任务可能会抛出异常，所以，我使用了Callable作为子任务的形式

        二、造子线程，我不可能每次都new 一个thread出来，肯定是要用线程池的，因为框架用的是springboot，所以选择使用ThreadPoolTaskExecutor作为线程池。

 那我们开始吧。

首先，配置线程池，并将其注入spring环境

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

import java.util.concurrent.ThreadPoolExecutor;

@Configuration
public class ExecutorConfig {
  @Bean("taskExecutor")
  public ThreadPoolTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    int i = Runtime.getRuntime().availableProcessors(); // 获取到服务器的cpu内核
    executor.setCorePoolSize(i + 1); // 核心池大小
    executor.setMaxPoolSize(64); // 最大线程数
    executor.setQueueCapacity(1000); // 队列程度
    executor.setKeepAliveSeconds(1000); // 线程空闲时间
    executor.setThreadNamePrefix("task-asyn"); // 线程前缀名称
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy()); // 配置拒绝策略
    return executor;
  }
}

具体配置可以按照你们的参数进行调整。我是因为项目里原先没配线程池，所以才加了一个，如果你们的项目里原先已经配置了线程池，那么直接用就行了。

@Resource(name = "taskExecutor")
private ThreadPoolTaskExecutor taskExecutor;

配置好线程池，使用注入，我们就能很方便的拿到子线程了。

其次，我们来构建子任务

public class RSATaskExecute<T> implements Callable<Boolean> {
  private List<T> list;
  private List<Field> fieldList;
  private String secretKey;
  private int type;
  private int start;
  private int end;

  public RSATaskExecute(
      List<T> list, List<Field> fieldList, String secretKey, int type, int start, int end) {
    //初始化的时候，可以传参进来，因为我这边使用了泛型，所以用了T，你们可以删掉<T>
    //按你们的业务需求写，即可
    this.list = list;
    this.fieldList = fieldList;
    this.secretKey = secretKey;
    this.type = type;
    this.start = start;
    this.end = end;
  }

  @Override
  public Boolean call() throws Exception {
    //这里写你们的业务代码
  }
}

主要是实现了Callable方法

倒数第二步，装载任务，将子任务装到子线程去运行

    List<Future> futureList = new ArrayList<>();
    for (int i = 0; i < core; i++) {
        int start = i * eve;
        int end = 0;
        if ((i + 1) * eve <= N) {
          end = (i + 1) * eve;
        } else {
          end = N;
        }
        //这里进行子线程装载子任务
        Future future =
            taskExecutor.submit(new RSATaskExecute(list, fieldList, privateKey, type, start, end));
        futureList.add(future);
      }

最后，等所有子任务完成后，才继续主线程

for (Future future : futureList) {
        future.get();
 }

如果future没有全部返回，主线程将阻塞。

Future类的 get（）方法可以当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕。

至此，任务分解为子任务，等所有子任务完成后，继续主线程就写好了。