解决多线程事务问题

不随意的风

已于 2023-08-12 09:42:06 修改

阅读量4.6k

点赞数 4

分类专栏：日常文章标签： java 开发语言

于 2023-01-12 16:12:17 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_71419462/article/details/128661612

版权

日常专栏收录该内容

15 篇文章

订阅专栏

文章介绍了如何在Spring中使用编程式事务处理多线程场景下的事务管理。通过示例展示了如何利用TransactionTemplate在每个线程中开启独立的事务，确保在出现错误时仅回滚相应线程的数据。同时，文中提到了使用CountDownLatch和AtomicBoolean进行线程间的同步，以实现特定情况下的全局事务回滚，并警告这种做法可能带来的资源消耗问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

spring的声明式事务在使用多线程时，并不会生效。可以使用spring提供的编程式事务解决。

核心思路是为每一个线程都开辟一个事务。

第一步：使用spring提供的编程式事务

 @Autowired
    private TransactionTemplate transactionTemplate;

第二步：在代码逻辑处写入业务逻辑

 transactionTemplate.execute(

       new TransactionCallbackWithoutResult(){
        @Override
   protected void doInTransactionWithoutResult(TransactionStatus status) {

    //代码逻辑
  userMapper.insertBatch(list);
            int m=1/0;
                        
        }
            }

 );

第三步：将上面的放入多线程中，线程池和new 线程都可以

executor.execute(() -> {
                    transactionTemplate.execute(

                            new TransactionCallbackWithoutResult(){
                                @Override
                                protected void doInTransactionWithoutResult(TransactionStatus status) {
                                    userMapper.insertBatch(list);
                                    int m=1/0;
  
 
                                }
                            }


                    );


                });

亲测有效，至于网上的提供的一些生成线程屏障的方法试了下不行，也不知道是不是我的问题。

demo供参考

@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private TransactionTemplate transactionTemplate;
    @Override
    public Result batchAdd(User... user) {


        if (user.length == 0) {
            throw new ServiceException("新增参数不能为空");
        }

        log.info("准备执行新增，当前需要新增数量为{}", user.length);
        if (user.length > 10) {

            int coreSize = user.length / 20 + 1;
            int size = user.length;

            //切片 每20个一次

            int batch = size % 20 == 0 ? size / 20 : size / 20 + 1;

            ThreadPoolExecutor executor = new ThreadPoolExecutor(coreSize, coreSize, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());


            log.info("线程池创建完毕，准备执行认为，线程数量为{}", coreSize);
          

            List<User> users = Arrays.asList(user);
            for (int i = 0; i < batch; i++) {
                int end = (i + 1) * 20;
                log.info("第{}个集合", i + 1);

                if (end > size) {
                    end = size;
                }

                List<User> list = users.subList(i * 20, end);
                log.info("集合大小为{}", list.size());


                int finalI = i;

                executor.execute(() -> {
                    transactionTemplate.execute(

                            new TransactionCallbackWithoutResult(){
                                @Override
                                protected void doInTransactionWithoutResult(TransactionStatus status) {
                                    userMapper.insertBatch(list);
                                    int m=1/0;
                                    List<Integer> ids = list.stream().map(User::getId).collect(Collectors.toList());
                                    log.info("新增成功用户成功，主键为{},当前线程为{}", ids, Thread.currentThread().getName());
                                    log.info("我执行了{}", finalI);
                                }
                            }


                    );


                });

            }



            executor.shutdown();
            log.info("批量增加完毕,线程池关闭");


        } else {

            if (saveBatch(Arrays.asList(user))) {
//                int a= 1/0;
                log.info("新增完成");
            } else {
                log.error("新增失败");
            }


        }


        return new Result();
    }

    @Override
    public Result getUserList(User user) {

        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(User::getId, User::getUserName, User::getPhone);
        wrapper.like(user.getUserName() != null, User::getUserName, user.getUserName())
                .eq(user.getPhone() != null, User::getPhone, user.getPhone());
        List<User> users = userMapper.selectList(wrapper);

        return new Result(users);
    }
}

更新一下内容：

当时是为了同步数据，适合某一线同步失败，只回滚当前线程的数据。发现评论有需要回滚全部的，给出了思路后，小伙伴依然有疑问，抽空写了个demo，供大家参考。使用的依旧是编程式事务，核心思路类似二阶段提交，生产中并不建议这样使用，线程之间的同步也需要耗费很多资源的，不要为了使用多线程而用。另外发现，批处理也可以做到这两种回滚，而且貌似更简单，有兴趣的可以自行研究下。

    public Result batchAdd(User... user) {


        if (user.length == 0) {
            throw new ServiceException("新增参数不能为空");
        }

        log.info("准备执行新增，当前需要新增数量为{}", user.length);
        if (user.length > 10) {

            int coreSize = user.length / 5+ 1;
            int size = user.length;

            //切片 每20个一次

            int batch = size % 5== 0 ? size / 5: size / 5 + 1;

            ThreadPoolExecutor executor = new ThreadPoolExecutor(coreSize, coreSize, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());


            log.info("线程池创建完毕，准备执行认为，线程数量为{}", coreSize);
          
            CountDownLatch latch = new CountDownLatch(batch);

            AtomicBoolean isError = new AtomicBoolean(false);

            List<User> users = Arrays.asList(user);
            for (int i = 0; i < batch; i++) {
                int end = (i + 1) * 5;
                log.info("第{}个集合", i + 1);

                if (end > size) {
                    end = size;
                }

                List<User> list = users.subList(i * 5, end);
                log.info("集合大小为{}", list.size());


                int finalI = i;

                executor.execute(() -> {
                    transactionTemplate.execute(

                    new TransactionCallbackWithoutResult(){
                                @Override
                                protected void doInTransactionWithoutResult(TransactionStatus status) {

                                    try {
                                        saveBatch(list);


                                        List<Integer> ids = list.stream().map(User::getId).collect(Collectors.toList());
                                        log.info("新增成功用户成功，主键为{},当前线程为{}", ids, Thread.currentThread().getName());
                                        log.info("我执行了{}", finalI);
                                       if(Thread.currentThread().getName().equals("pool-1-thread-2")){
                                            int m=1/0;
                                        }
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                        System.out.println("ssss");
                                        isError.set(true);
                                    } finally {
                                        System.out.println("r");
                                        latch.countDown();
                                    }


                                    try {
                                        latch.await();
                                        if (isError.get()){
                                            status.setRollbackOnly();
                                        }
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                        throw new RuntimeException("出错啦");
                                    }


                                }
                            }


                    );


                });





            }

            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            executor.shutdown();
            log.info("批量增加完毕,线程池关闭");


        } 


        return new Result();
    }