spring多线程事务控制

@Component
public class TxThreadUtil {
    
    

    @Autowired
    private PlatformTransactionManager transactionManager;

    @Autowired
    private TransactionDefinition transactionDefinition;


    @Autowired
    private AuthorMapper authorMapper;


    public void main() {
    
    
        List<Supplier<Boolean>> tasks = new ArrayList<>();
        tasks.add(() -> {
    
    
            Author author = new Author();
            author.setId(1);
            author.setNickname("李白");
            author.setEmail("测试xxxxxxxxxxxxxxxx");
            saveBatch(Lists.newArrayList(author));
            return true;
        });

        tasks.add(() -> {
    
    
            Author author = new Author();
            author.setId(4);
            author.setNickname("韩信");
            author.setEmail("测试xxxxxxxxxxxxxxxx");
            saveBatch(Lists.newArrayList(author));
            return true;
        });

        tasks.add(() -> {
    
    
            Author author = new Author();
            author.setId(5);
            author.setNickname("赵云");
            author.setEmail("测试xxxxxxxxxxxxxxxx");
            saveBatch(Lists.newArrayList(author));
            return true;
        });

        Long startTime = System.currentTimeMillis();
        // 主线程事务
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus mainstatus = transactionManager.getTransaction(def);


        //定义子线程返回的结果集合如果全部为true则事务提交
        List<Boolean> result = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < tasks.size(); i++) {
    
    
            result.add(false);
        }


        try {
    
    
            execute(tasks, result);

            boolean b = true;
            for (Boolean res : result) {
    
    
                b &= res;
            }

            if(b){
    
    
                // TODO 执行主线程的业务
                System.out.println("主线程业务");

                transactionManager.commit(mainstatus);
            }else{
    
    
                transactionManager.rollback(mainstatus);
            }
        } catch (Exception e) {
    
    
            mainstatus.setRollbackOnly();
        }

        System.out.println("耗时"+(System.currentTimeMillis()-startTime)+"ms");

    }



    public void execute(List<Supplier<Boolean>> tasks, List<Boolean> result) throws InterruptedException {
    
    
        // 任务个数
        int n = tasks.size();
        //暂停当前线程
        CountDownLatch mainLatch = new CountDownLatch(1);
        //线程计数器
        CountDownLatch sonLatch = new CountDownLatch(n);
        for (int i = 0; i < n; i++) {
    
    
            int index = i;
            Executors.newCachedThreadPool().execute(() -> {
    
    

                //子线程手动开启事务
                DefaultTransactionDefinition def = new DefaultTransactionDefinition(transactionDefinition);
                def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                TransactionStatus status = transactionManager.getTransaction(def);

                try {
    
    
                    //执行业务逻辑
                    Boolean executeFlag = tasks.get(index).get();
                    if(executeFlag){
    
    
                        //收集正常结果
                        result.set(index, true);
                        //计数
                        sonLatch.countDown();

                        //执行成功先暂停线程  等待其他线程执行结果
                        mainLatch.await();

                        // 当所有子线业务执行完毕，主线程countdown，统一提交事务
                        // 此时需要判断是否有线程执行失败，如果有线程执行失败则回滚事务
                        boolean b = true;
                        for (Boolean res : result) {
    
    
                            b &= res;
                        }
                        if(b){
    
    
                            transactionManager.commit(status);
                        }else{
    
    
                            transactionManager.rollback(status);
                        }
                    }else{
    
    
                        sonLatch.countDown();
                        //收集异常结果
                        result.set(index, false);
                        transactionManager.rollback(status);
                    }
                } catch (Exception e) {
    
    
                    sonLatch.countDown();
                    //收集异常结果
                    result.set(index, false);
                    transactionManager.rollback(status);
                }
            });
        }

        //等待全部线程都执行玩业务操作
        sonLatch.await();
        //放行 （执行全部子线程后面的代码）
        mainLatch.countDown();
        //等待子线程执行完成（此时子线程如果状态集合都为true事务已经提交）
        mainLatch.await();
    }
    
    private boolean saveBatch(List<Author> authors) {
    
    
        for (Author author : authors) {
    
    
            authorMapper.insert(author);
        }
        return true;
    }

}