多线程批量执行事务处理

背景：有个数据量很大的列表，需要插入，由于数据量过大，所以分批批量插入，然后这些插入没有关联性，所以使用多线程来执行，提高效率，但是如果其中某一次执行失败，需要整体回滚；

如下是核心代码：

//批量插
        List<LockCurrencyReturnSettle> list = new ArrayList<>(userTotalBuyRecord.size());
        for (LockCurrencyBuyRecordVo vo : userTotalBuyRecord) {
            LockCurrencyReturnSettle returnSettle = LockCurrencyReturnSettle.builder()
                    .id(IDUtil.nextUUID())
                    .userId(vo.getUserId())
                    .payCurrencyName(vo.getCurrencyName())
                    .payTotalAmount(vo.getTotalAmount().setScale(4, BigDecimal.ROUND_HALF_UP))
                    .returnDays(lockCurrencyActivityConfig.getLockedDays())
                    .remainDays(lockCurrencyActivityConfig.getLockedDays())
                    .returnInterestCurrencyName(RETURN_INTEREST_CURRENCYNAME)
                    .returnTotalInterest(vo.getTotalUsdtAmount().multiply(rewardRatio).setScale(8, BigDecimal.ROUND_HALF_UP))
                    .returnRemainInterest(vo.getTotalUsdtAmount().multiply(rewardRatio).setScale(8, BigDecimal.ROUND_HALF_UP))
                    .returnTotalPrincipal(vo.getTotalAmount().setScale(4, BigDecimal.ROUND_HALF_UP))
                    .returnRemainPrincipal(vo.getTotalAmount().setScale(4, BigDecimal.ROUND_HALF_UP))
                    .rewardRatio(rewardRatio.setScale(2, BigDecimal.ROUND_HALF_UP))
                    .build();
            list.add(returnSettle);
        }
        //线程数=list.size()/500
        int threadNum = 0;
        if (list.size() % LOCK_CURRENCY_THREAD_SIZE == 0) {
            threadNum = list.size() / LOCK_CURRENCY_THREAD_SIZE;
        } else {
            threadNum = list.size() / LOCK_CURRENCY_THREAD_SIZE + 1;
        }
        //创建一个线程池
        ExecutorService eService = Executors.newFixedThreadPool(threadNum);
        //子线程
        CountDownLatch rollBackLatch = new CountDownLatch(1);
        //主线程
        CountDownLatch mainThreadLatch = new CountDownLatch(threadNum);
        // 是否存在异常
        AtomicReference<Boolean> isError = new AtomicReference<>(false);
        List<LockCurrencyReturnSettle> sList;//截取list
        try {
            for (int i = 0; i < threadNum; i++) {
                if (i == threadNum - 1) {
                    sList = list.subList(i * LOCK_CURRENCY_THREAD_SIZE, list.size());
                } else {
                    sList = list.subList(i * LOCK_CURRENCY_THREAD_SIZE, (i + 1) * LOCK_CURRENCY_THREAD_SIZE);
                }
                final List<LockCurrencyReturnSettle> nowList = sList;
                eService.execute(() -> {
                    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
                    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                    TransactionStatus status = dataSourceTransactionManager.getTransaction(def);
                    try {
                        int batchInsertCount = lockCurrencyReturnSettleMapper.batchInsert(nowList);
                        if (batchInsertCount != nowList.size()) {
                            // 接受异常 处理异常
                            isError.set(true);
                            log.error("分段增加购买记录表失败");
                            throw new AppException(ResultEnum.LOCK_CURRENCY_TRANSACTION_FAIL);
                        }
                        mainThreadLatch.countDown();
                        rollBackLatch.await();
                        if (isError.get()) {
                            dataSourceTransactionManager.rollback(status);
                        } else {
                            dataSourceTransactionManager.commit(status);
                        }
                    } catch (Exception exception) {
                        // 接受异常 处理异常
                        isError.set(true);
                        mainThreadLatch.countDown();
                        log.error("分段增加购买记录表失败{}", exception);
                        throw new AppException(ResultEnum.LOCK_CURRENCY_TRANSACTION_FAIL);
                    }

                });
            }
            mainThreadLatch.await();
            //所有等待的子线程全部放开
            rollBackLatch.countDown();
            if (isError.get()) {
                log.error("增加购买记录表失败");
                throw new AppException(ResultEnum.LOCK_CURRENCY_TRANSACTION_FAIL);
            }