2022-04-07 多线程

1.线程池配置

@SpringBootApplication
public class CryptoApplication {

    public static void main(String[] args) {
        SpringApplication.run(CryptoApplication.class, args);
    }

    @EnableAsync
    @Configuration
    class TaskPoolConfig {
        @Bean("backExecutor")
        public Executor taskExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            // 核心线程数：线程池创建时候初始化的线程数
            executor.setCorePoolSize(10);
            // 最大线程数：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
            executor.setMaxPoolSize(20);
            // 缓冲队列：用来缓冲执行任务的队列
            executor.setQueueCapacity(5);
            // 允许线程的空闲时间60秒：当超过了核心线程之外的线程在空闲时间到达之后会被销毁
            executor.setKeepAliveSeconds(60);
            // 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
            executor.setThreadNamePrefix("backExecutor-");
            // 缓冲队列满了之后的拒绝策略：由调用线程处理（一般是主线程）
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
            executor.initialize();
            return executor;
        }

    }

}

2.异步方法

@Async("backExecutor")
public CompletableFuture<R> getRate(List<LatestCurrencyPriceRes> latestCurrencyPriceResList, ExchangeInfoEntity exchangeInfoEntity) {
    LatestCurrencyPriceRes latestCurrencyPriceRes = new LatestCurrencyPriceRes();
    NewQuotedPriceResVo newQuotedPriceResVo = coreCustomerInfoService.newQuotedPrice(exchangeInfoEntity.getExchangeId());
    latestCurrencyPriceRes.setExchangeId(exchangeInfoEntity.getExchangeId());
    latestCurrencyPriceRes.setExchangeName(exchangeInfoEntity.getExchangeName());
    if (CoreErrorCodeEnum.SUCCESS.getValue().equals(newQuotedPriceResVo.getCoreResCode())) {
        latestCurrencyPriceRes.setListQuotedPrice(newQuotedPriceResVo.getListQuotedPrice());
    } else {
        return CompletableFuture.completedFuture(R.error(newQuotedPriceResVo.getCoreResMsg()));
    }
    //组装USD与USDT之间汇率
    VirtualCurrencyPriceEntity virtualCurrencyPriceEntityUSD2USDC =
            virtualCurrencyPriceDao.selectByFrom2ToCurrency(CurrencyTypeEnum.USD.getValue(), CurrencyTypeEnum.USDC.getValue());
    if (virtualCurrencyPriceEntityUSD2USDC != null) {
        QuotedPriceVo quotedPriceVoUSD2USDC = new QuotedPriceVo();
        quotedPriceVoUSD2USDC.setCurrency(CurrencyTypeEnum.USD);
        quotedPriceVoUSD2USDC.setPrice(virtualCurrencyPriceEntityUSD2USDC.getActualPrice());
        quotedPriceVoUSD2USDC.setContrastCurrency(CurrencyTypeEnum.USDC);
        quotedPriceVoUSD2USDC.setTime(virtualCurrencyPriceEntityUSD2USDC.getCreateTime());
        latestCurrencyPriceRes.getListQuotedPrice().add(quotedPriceVoUSD2USDC);
    }


    VirtualCurrencyPriceEntity virtualCurrencyPriceEntityUSDC2USD =
            virtualCurrencyPriceDao.selectByFrom2ToCurrency(CurrencyTypeEnum.USDC.getValue(), CurrencyTypeEnum.USD.getValue());
    if (virtualCurrencyPriceEntityUSDC2USD != null) {
        QuotedPriceVo quotedPriceVoUSDC2USD = new QuotedPriceVo();
        quotedPriceVoUSDC2USD.setCurrency(CurrencyTypeEnum.USDC);
        quotedPriceVoUSDC2USD.setPrice(virtualCurrencyPriceEntityUSDC2USD.getActualPrice());
        quotedPriceVoUSDC2USD.setContrastCurrency(CurrencyTypeEnum.USD);
        quotedPriceVoUSDC2USD.setTime(virtualCurrencyPriceEntityUSDC2USD.getCreateTime());
        latestCurrencyPriceRes.getListQuotedPrice().add(quotedPriceVoUSDC2USD);
    }
    latestCurrencyPriceResList.add(latestCurrencyPriceRes);
    return CompletableFuture.completedFuture(null);
}

3.返回处理

public R latestCurrencyPrice() {
    List<LatestCurrencyPriceRes> latestCurrencyPriceResList = new CopyOnWriteArrayList<>();//异步容器
    List<ExchangeInfoEntity> exchangeInfoEntityList = exchangeInfoService.list(new QueryWrapper<ExchangeInfoEntity>().lambda()
            .orderByDesc(ExchangeInfoEntity::getUpdateTime));
    if (CollectionUtil.isNotEmpty(exchangeInfoEntityList)) {
        //异步获取汇率
        List<CompletableFuture> asyncResultList = new CopyOnWriteArrayList<>();
        for (ExchangeInfoEntity exchangeInfoEntity : exchangeInfoEntityList) {
            CompletableFuture<R> asyncResult = asyncService.getRate(latestCurrencyPriceResList, exchangeInfoEntity);
            asyncResultList.add(asyncResult);
        }

        //等待所有任务执行完成
        if (CollectionUtil.isNotEmpty(asyncResultList)) {
            CompletableFuture<R>[] completableFutures = asyncResultList.toArray(new CompletableFuture[asyncResultList.size()]);
            CompletableFuture.allOf(completableFutures).join();//等待所有任务执行完毕
            for (CompletableFuture<R> completableFuture : completableFutures) {
                try {
                    if (completableFuture.get() != null) {//获取返回值
                        R r = completableFuture.get();
                        log.error("获取汇率失败：" + r.get("msg").toString());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
    return R.ok().put("result", latestCurrencyPriceResList);
}