增加索引 + 异步 + 不落地后，从 12h 优化到 15 min

@Value("${months}")
private String months;

@Value("${imgDir}")
private String imgDir;

@Resource
private UserDao userDao;

@Override
public void getUserInfoImg() {
 try {
  // 获取需要导出的月表
  String[] monthArr = months.split(",");
  for (int i = 0; i < monthArr.length; i++) {
   // 获取月表中的图片
   Map<String, Object> map = new HashMap<String, Object>();
   String tableName = "USER_INFO_" + monthArr[i];
   map.put("tableName", tableName);
   map.put("status", 1);
   
   List<UserInfo> userInfoList = userDao.getUserInfoImg(map);
   if (userInfoList == null || userInfoList.size() == 0) {
    return;
   }

   for (int j = 0; j < userInfoList.size(); j++) {
    UserInfo user = userInfoList.get(j);
    String userId = user.getUserId();
    String userName = user.getUserName();
    byte[] content = user.getImgContent;

    // 下载图片到本地
    FileUtil.dowmloadImage(imgDir + userId+"-"+userName+".png", content);
    
    // 将下载好的图片，通过FTP上传给第三方
    FileUtil.uploadByFtp(imgDir);
   }
  }
 } catch (Exception e) {
  serviceLogger.error("获取图片异常：", e);
 }
}

@Resource
private UserAsyncService userAsyncService;

@Override
public void getUserInfoImg() {
 try {
  // 获取需要导出的月表
  String[] monthArr = months.split(",");
  for (int i = 0; i < monthArr.length; i++) {
   userAsyncService.getUserInfoImgAsync(monthArr[i]);
  }
 } catch (Exception e) {
  serviceLogger.error("获取图片异常：", e);
 }
}

@Value("${months}")
private String months;

@Resource
private UserDao userDao;

@Async("async-executor")
@Override
public void getUserInfoImgAsync(String month) {
 try {
  // 获取月表中的图片
  Map<String, Object> map = new HashMap<String, Object>();
  String tableName = "USER_INFO_" + month;
  map.put("tableName", tableName);
  map.put("status", 1);
  
  List<UserInfo> userInfoList = userDao.getUserInfoImg(map);
  if (userInfoList == null || userInfoList.size() == 0) {
   return;
  }

  for (int i = 0; i < userInfoList.size(); i++) {
   UserInfo user = userInfoList.get(i);
   String userId = user.getUserId();
   String userName = user.getUserName();
   byte[] content = user.getImgContent;
   
   // 不落地，直接通过FTP上传给第三方
   FileUtil.uploadByFtp(content);
  }
 } catch (Exception e) {
  serviceLogger.error("获取图片异常：", e);
 }
}

spring:
  task:
    execution:
      pool:
        max-size: 10
        core-size: 5
        keep-alive: 3s
        queue-capacity: 1000
        thread-name-prefix: my-executor

@EnableAsync// 支持异步操作
@Configuration
public class AsyncTaskConfig {

    /**
     * com.google.guava中的线程池
     * @return
     */
    @Bean("my-executor")
    public Executor firstExecutor() {
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("my-executor").build();
        // 获取CPU的处理器数量
        int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(curSystemThreads, 100,
                200, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(), threadFactory);
        threadPool.allowsCoreThreadTimeOut();
        return threadPool;
    }

    /**
     * Spring线程池
     * @return
     */
    @Bean("async-executor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        // 核心线程数
        taskExecutor.setCorePoolSize(24);
        // 线程池维护线程的最大数量，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        taskExecutor.setMaxPoolSize(200);
        // 缓存队列
        taskExecutor.setQueueCapacity(50);
        // 空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
        taskExecutor.setKeepAliveSeconds(200);
        // 异步方法内部线程名称
        taskExecutor.setThreadNamePrefix("async-executor-");

        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}

public static void main(String[] args) {
    // 创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(10);
    
    // 使用线程池创建CompletableFuture对象
    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
        // 一些不为人知的操作
        return "result"; // 返回结果
    }, executor);
    
    // 使用CompletableFuture对象执行任务
    CompletableFuture<String> result = future.thenApply(result -> {
        // 一些不为人知的操作
        return "result"; // 返回结果
    });
    
    // 处理任务结果
    String finalResult = result.join();
    
    // 关闭线程池
    executor.shutdown();
}

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        System.out.println(list);
        List<Integer> result = list.stream().parallel().map(i -> i++).collect(Collectors.toList());
        System.out.println(result);
    }
}