int pageSize = 10000;

         int totalCount = doctorDAO.selectDatasByMapCount2(jsonArray, false, null);

         int m = totalCount % pageSize;

         int pageCount = m == 0 ? (totalCount / pageSize) : (totalCount / pageSize + 1);

         List<DoctorDO> resultList = new ArrayList<>();

         BlockingQueue<Future<List<DoctorDO>>> queue = new LinkedBlockingQueue<>();

         for (int i = 0; i < pageCount; i++) {

             Thread.sleep(0);

             Future<List<DoctorDO>> future;

             future = queryDatas(jsonArray, i * pageSize, pageSize);

             queue.add(future);

         }

         int queueSize = queue.size();

         logger.debug("queue size:" + queueSize);

         for (int i = 0; i < queueSize; i++) {

             List<DoctorDO> subAttendList = queue.take().get();

             if (!CollectionUtils.isEmpty(subAttendList)) {

                 resultList.addAll(subAttendList);

             }

         }

     @Async

     public Future<List<DoctorDO>> queryDatas(JSONArray jsonArray, int start, int size) {

         List<DoctorDO> subAttendList = doctorDAO.selectDatasByMap2(start, size, jsonArray, true, null);

         logger.info("完成任务");

         return new AsyncResult<>(subAttendList);

     }

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;

 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.lang.reflect.Method;

 import java.util.concurrent.Executor;

 /**

  * 多线程配置类

  */

 @Configuration

 @EnableAsync

 public class ThreadConfig implements AsyncConfigurer {

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

     /**

      * The {@link Executor} instance to be used when processing async

      * method invocations.

      */

     @Override

     public Executor getAsyncExecutor() {

         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

         executor.setCorePoolSize(15);

         executor.setMaxPoolSize(25);

         executor.setQueueCapacity(25);

         executor.initialize();

         return executor;

     }

     /**

      * The {@link AsyncUncaughtExceptionHandler} instance to be used

      * when an exception is thrown during an asynchronous method execution

      * with {@code void} return type.

      */

     @Override

     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

         return new SpringAsyncExceptionHandler();

     }

     class SpringAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

         @Override

         public void handleUncaughtException(Throwable throwable, Method method, Object... obj) {

             throwable.printStackTrace();

         }

     }

     public static void main(String[] args) {

         logger.info("123");

         logger.info("123");

         logger.info("123");

     }

 }