今天做导出 查出的数据有3万条 还要遍历做一些处理 结果就超时
 
想到多线程遍历list 去网上查找 找到这块代码：
 
public String list2Str(List list, final int nThreads) throws Exception {
 
if (list == null || list.isEmpty()) {
 
return null;
 
}
 
StringBuffer ret = new StringBuffer();
 
int size = list.size();
 
ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
 
List> futures = new ArrayList>(nThreads);
 
for (int i = 0; i < nThreads; i++) {
 
final List subList = list.subList(size / nThreads * i, size / nThreads * (i + 1));
 
Callable task = new Callable() {
 
@Override
 
public String call() throws Exception {
 
StringBuffer sb = new StringBuffer();
 
for (String str : subList) {
 
sb.append(str);
 
}
 
return sb.toString();
 
}
 
};
 
futures.add(executorService.submit(task));
 
}
 
for (Future future : futures) {
 
ret.append(future.get());
 
}
 
executorService.shutdown();
 
return ret.toString();
 
}
 
}
 
我调用时开了5个线程 我想问 每次导出就开启5个线程 如果多个人同时导出 比如10000个人同时导出 那岂不是就开启了50000个线程了！！！
 
没问题吗？？？

开发过程中经常遇到如下需求，拿到一个list数据，需要遍历它然后请求第三方接口，然后根据返回结果做一些事
 
常规写法
 
public static void main(String[] args) {
    List<User> list = getList();
    test1(list);
}

//假设有500条数据
static List<User> getList() {
    List<User> list = new ArrayList<>();
    for (int i = 1; i < 501; i++) {
        User user = new User();
        user.setIdCard(i + "");
        list.add(user);
    }
    return list;
}

//常规的单线程处理方法
static void test1(List<User> list) {
    long start = System.currentTimeMillis();
    for (User user : list) {
        sendRequest(user);
    }
    long end = System.currentTimeMillis();
    System.out.println("单线程方法，耗时：" + (end - start) + "ms");
}

//模拟请求第三方接口：根据身份证号获取姓名
static void sendRequest(User user){
    //模拟接口请求耗时
    try {
        Thread.sleep(10);
    } catch (Exception e){}
    //模拟获取请求结果后做的一些事
    user.setName("张三-" + user.getIdCard());
    System.out.println("=====> 发送请求： name=" + user.getName());
}

@Data
class User {
    private String idCard;
    private String name;
}
 
我们使用模拟数据造了 500 条数据，然后for循环列表去请求第三方接口获取数据，总共耗时大约为10 * 500 = 5000ms 以上
 
 使用多线程改造后：
 
public static void main(String[] args) {
    List<User> list = getList();
    test2(list);
}

//......省略getList()，上面有

//多线程处理
static void test2(List<User> list) {
    long start = System.currentTimeMillis();
    ExecutorService executor = Executors.newFixedThreadPool(10);
    final CountDownLatch countDownLatch = new CountDownLatch(list.size());
    for (User user : list) {
        executor.execute(new Task(user, countDownLatch));
    }
    try {
        countDownLatch.await();
    } catch (Exception e) {

    } finally {
        executor.shutdown();
    }
    long end = System.currentTimeMillis();
    System.out.println("多线程方法，耗时：" + (end - start) + "ms");
}

//实现Runnable的多线程类
static class Task implements  Runnable {

        private User user;
        private CountDownLatch countDownLatch;

        public Task(User user, CountDownLatch countDownLatch) {
            this.user = user;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                sendRequest(user);
            } catch (Exception e) {

            } finally {
                countDownLatch.countDown();
            }
        }
    }
 
结果：
 
 注意事项：
 
正常情况下，我们需要等多线程处理完，获取list数据，再去做一些业务操作（如入库，导出数据等），如果不需要等待结果，可以去掉countDownLatch，速度会更快
Task的run方法最好使用try...catch...finally，保证无论sendRequest()方法执行成功与否，countDownLatch都能减1，防止多线程无法终止
 
完整Demo
 
public class ForThreadTest {

    public static void main(String[] args) {
        List<User> list = getList();
        test1(list);
        test2(list);
    }

    //常规的单线程处理方法
    static void test1(List<User> list) {
        long start = System.currentTimeMillis();
        for (User user : list) {
            sendRequest(user);
        }
        long end = System.currentTimeMillis();
        System.out.println("单线程方法，耗时：" + (end - start) + "ms");
    }

    //多线程
    static void test2(List<User> list) {
        long start = System.currentTimeMillis();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        final CountDownLatch countDownLatch = new CountDownLatch(list.size());
        for (User user : list) {
            executor.execute(new Task(user, countDownLatch));
        }
        try {
            countDownLatch.await();
        } catch (Exception e) {
    
        } finally {
            executor.shutdown();
        }
        long end = System.currentTimeMillis();
        System.out.println("多线程方法，耗时：" + (end - start) + "ms");
    }


    //假设有500条数据
    static List<User> getList() {
        List<User> list = new ArrayList<>();
        for (int i = 1; i < 501; i++) {
            User user = new User();
            user.setIdCard(i + "");
            list.add(user);
        }
        return list;
    }

    //模拟请求第三方接口：根据身份证号获取姓名
    static void sendRequest(User user){
        //模拟接口请求耗时
        try {
            Thread.sleep(10);
        } catch (Exception e){}
        //模拟获取请求结果后做的一些事
        user.setName("张三-" + user.getIdCard());
        System.out.println("=====> 发送请求： name=" + user.getName());
    }

    static class Task implements  Runnable {

        private User user;
        private CountDownLatch countDownLatch;

        public Task(User user, CountDownLatch countDownLatch) {
            this.user = user;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                sendRequest(user);
            } catch (Exception e) {

            } finally {
                countDownLatch.countDown();
            }
        }
    }
}

@Data
class User {
    private String idCard;
    private String name;
}

 
import java.util.ArrayList;
 
import java.util.List;
 
import static java.lang.Thread.sleep;
 
public class Test3 {
 
public static void main(String[] args) throws Exception {
 
long start = System.currentTimeMillis();
 
List list = new ArrayList<>(1000);
 
int count = 0 ;
 
for (int i = 0; i < 1000; i++) {
 
list.add("a_"+count);
 
count++;
 
}
 
// list.parallelStream().forEach(item -> {
 
list.parallelStream().forEachOrdered(item -> {
 
try {
 
sleep(1);
 
} catch (InterruptedException e) {
 
e.printStackTrace();
 
}
 
System.out.println("item = " + item);
 
});
 
/*for (int i = 0; i 
 
sleep(1);
 
System.out.println("item = " + list.get(i));
 
}*/
 
long end = System.currentTimeMillis();
 
System.out.println("总时间 = " + (end - start));
 
}
 
}

Springboot自定义线程池，多线程遍历list及有返回值
 
自定义连接池
 
/**
 * @description: 某功能公共线程池
 * @author: zjq
 * @create: 2021-01-06 15:35
 **/
@Configuration
public class TranslationThreadPoolConfig {
    // 核心线程池大小
    private int corePoolSize = 20;

    // 最大可创建的线程数
    private int maxPoolSize = 50;

    // 队列最大长度
    private int queueCapacity = 1000;

    // 线程池维护线程所允许的空闲时间
    private int keepAliveSeconds = 300;

    //线程名称前缀
    private String threadNamePrefix="线程名称前缀";

    @Primary
    @Bean(name = "translationThreadPoolTaskExecutor")
    public ThreadPoolTaskExecutor translationThreadPoolTaskExecutor()
    {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(maxPoolSize);
        executor.setCorePoolSize(corePoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix(threadNamePrefix);
        // 线程池对拒绝任务(无线程可用)的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}
 
service层调用
 
1.serviceImpl其他代码忽略
 
2.依赖注入自定义线程池对象
 
   @Autowired
   @Qualifier("translationThreadPoolTaskExecutor")
   private Executor executor;
 
3.方法调用
 
//需要多线程遍历的list
List<Map<String, Object>> waitSortBizDatas =new ArrayList(Map<String, Object>);
//多线程执行行转译
List<CompletableFuture<RuleResult>> collect = waitSortBizDatas.stream().map(waitSortBizData -> CompletableFuture.supplyAsync(() ->                                 
        //调用别的方法
        iAccRuleService.ruleExecute(voucherLineId, ruleIds,bizTable.getTableCode(), waitSortBizData), executor)
        ).collect(Collectors.toList());
//获取返回值
List<RuleResult> list = collect.stream().map(CompletableFuture::join).collect(Collectors.toList());