spring多线程事务控制

本测试多个子线程执行业务操作，我这只是简单的执行了批量添加，网上找了很多例子，杂七杂八的要么就是写的有bug要么就是运行结果不一致没效果，最后干脆自己写一个。
话不多说直接上代码:

    @Autowired
    private PlatformTransactionManager transactionManager;

```/**
     * 将一组数据平均分成n组
     *
     * @param source 要分组的数据源
     * @param n      平均分成n组
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> averageAssign(List<T> source, int n) {
        List<List<T>> result = new ArrayList<>();
        int remainder = source.size() % n;  //(先计算出余数)
        int number = source.size() / n;  //然后是商
        int offset = 0;//偏移量
        for (int i = 0; i < n; i++) {
            List<T> value = null;
            if (remainder > 0) {
                value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
                remainder--;
                offset++;
            } else {
                value = source.subList(i * number + offset, (i + 1) * number + offset);
            }
            result.add(value);
        }
        return result;
    }
// 以上是工具类


    public void test() {
        Long startTime = System.currentTimeMillis();
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        // 获得事务状态
        TransactionStatus mainstatus = transactionManager.getTransaction(def);
        List<ZlTypeEntity> list = new ArrayList<>();
        ZlTypeEntity zlTypeEntity = null;
        for (int i = 0; i < 500000; i++) {
            zlTypeEntity = new ZlTypeEntity();
            zlTypeEntity.setName("测试" + i);
            list.add(zlTypeEntity);
        }
        //将list分成三组
        List<List<ZlTypeEntity>> listgp = ListFgUtils.averageAssign(list, 3);
       //定义子线程返回的结果集合如果全部为true则事务提交
        List<Boolean> bullist=Collections.synchronizedList(new ArrayList<>());
        //暂停当前线程
        CountDownLatch latch = new CountDownLatch(1);
        //线程计数器
        CountDownLatch cdAnswer = new CountDownLatch(2);
        for (int i = 0; i < 2; i++) {
            int finalI=i;
            ExecutorPoolUtil.fixedExecutorDiy.execute(new Runnable() {
                @Override
                public void run() {
                    AtomicInteger atomicInteger=new AtomicInteger();
                    atomicInteger.set(finalI+1);
                    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
                    // 事物隔离级别，开启新事务
                    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                    // 获得事务状态
                    TransactionStatus status = transactionManager.getTransaction(def);
                    try {
                        //执行业务逻辑  子线程添加
                       AtomicBoolean a= new AtomicBoolean(saveBatch(listgp.get(atomicInteger.get())));
                       //计数
                        cdAnswer.countDown();
                       if(a.get()){
                           //添加
                           bullist.add(true);
                           //执行成功先暂停线程  等待其他线程执行结果
                           latch.await();
                           AtomicBoolean x=new AtomicBoolean(true);
                           for(int i=0;i<bullist.size();i++){
                              if(!bullist.get(i)){
                                  x.set(bullist.get(i));
                                  break;
                              }
                          }
                          if(x.get()){
                              transactionManager.commit(status);
                          }
                       }else{
                           bullist.add(false);
                       }
                    } catch (Exception e) {
                        //计数
                        cdAnswer.countDown();
                        //执行异常
                        bullist.add(false);
                        status.setRollbackOnly();
                    }
                }
            });
        }
        try{
            //等待全部线程都执行玩业务操作  （执行完后这时集合才会有全部的状态数据）
            cdAnswer.await();
            //放行 （执行全部子线程后面的代码）
            latch.countDown();
            //等待子线程执行完成（此时子线程如果状态集合都为true事务已经提交）
            latch.await();
   
            AtomicBoolean x=new AtomicBoolean(true);
          //主线程判断子线程时候有执行失败的
            for(int i=0;i<bullist.size();i++){
                if(!bullist.get(i)){
                    x.set(bullist.get(i));
                    break;
                }
            }
            //主线程添加
            saveBatch(listgp.get(0));
           
            if(x.get()){
      //没有则提交事务
                transactionManager.commit(mainstatus);
            }else{
                mainstatus.setRollbackOnly();
            }
        }catch (Exception e){
            mainstatus.setRollbackOnly();
        }
        System.out.println("耗时"+(System.currentTimeMillis()-startTime)+"ms");
    }