服务粉丝

我们一直在努力
当前位置：首页 > 财经 >

支付宝：多线程事务怎么回滚？说用 @Transactional 可以回去等通知了！

日期： 来源：石杉的架构笔记收集编辑：weixin_43225491
「 关注“石杉的架构笔记”，大厂架构经验倾囊相授 」

文章来源：http://t.csdn.cn/1GFvZ

目录
  • 背景介绍
  • 公用的类和方法
  • 示例事务不成功操作
  • 使用sqlSession控制手动提交事务




背景介绍





1，最近有一个大数据量插入的操作入库的业务场景，需要先做一些其他修改操作，然后在执行插入操作，由于插入数据可能会很多，用到多线程去拆分数据并行处理来提高响应时间，如果有一个线程执行失败，则全部回滚。

2，在spring中可以使用@Transactional注解去控制事务，使出现异常时会进行回滚，在多线程中，这个注解则不会生效，如果主线程需要先执行一些修改数据库的操作，当子线程在进行处理出现异常时，主线程修改的数据则不会回滚，导致数据错误。

3，下面用一个简单示例演示多线程事务。


公用的类和方法





/**
 * 平均拆分list方法.
 * @param source
 * @param n
 * @param <T>
 * @return
 */
public static <T> List<List<T>> averageAssign(List<T> source,int n){
    List<List<T>> result=new ArrayList<List<T>>();
    int remaider=source.size()%n; 
    int number=source.size()/n; 
    int offset=0;//偏移量
    for(int i=0;i<n;i++){
        List<T> value=null;
        if(remaider>0){
            value=source.subList(i*number+offset, (i+1)*number+offset+1);
            remaider--;
            offset++;
        }else{
            value=source.subList(i*number+offset, (i+1)*number+offset);
        }
        result.add(value);
    }
    return result;
}
/**  线程池配置
 * @version V1.0
 */
public class ExecutorConfig {
    private static int maxPoolSize = Runtime.getRuntime().availableProcessors();
    private volatile static ExecutorService executorService;
    public static ExecutorService getThreadPool() {
        if (executorService == null){
            synchronized (ExecutorConfig.class){
                if (executorService == null){
                    executorService =  newThreadPool();
                }
            }
        }
        return executorService;
    }

    private static  ExecutorService newThreadPool(){
        int queueSize = 500;
        int corePool = Math.min(5, maxPoolSize);
        return new ThreadPoolExecutor(corePool, maxPoolSize, 10000L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(queueSize),new ThreadPoolExecutor.AbortPolicy());
    }
    private ExecutorConfig(){}
}
/** 获取sqlSession
 * @author 86182
 * @version V1.0
 */
@Component
public class SqlContext {
    @Resource
    private SqlSessionTemplate sqlSessionTemplate;

    public SqlSession getSqlSession(){
        SqlSessionFactory sqlSessionFactory = sqlSessionTemplate.getSqlSessionFactory();
        return sqlSessionFactory.openSession();
    }
}



示例事务不成功操作





  /**
 * 测试多线程事务.
 * @param employeeDOList
 */
@Override
@Transactional
public void saveThread(List<EmployeeDO> employeeDOList) {
    try {
        //先做删除操作,如果子线程出现异常,此操作不会回滚
        this.getBaseMapper().delete(null);
        //获取线程池
        ExecutorService service = ExecutorConfig.getThreadPool();
        //拆分数据,拆分5份
        List<List<EmployeeDO>> lists=averageAssign(employeeDOList, 5);
        //执行的线程
        Thread []threadArray = new Thread[lists.size()];
        //监控子线程执行完毕,再执行主线程,要不然会导致主线程关闭,子线程也会随着关闭
        CountDownLatch countDownLatch = new CountDownLatch(lists.size());
        AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        for (int i =0;i<lists.size();i++){
            if (i==lists.size()-1){
                atomicBoolean.set(false);
            }
            List<EmployeeDO> list  = lists.get(i);
            threadArray[i] =  new Thread(() -> {
                try {
                 //最后一个线程抛出异常
                    if (!atomicBoolean.get()){
                        throw new ServiceException("001","出现异常");
                    }
                    //批量添加,mybatisPlus中自带的batch方法
                    this.saveBatch(list);
                }finally {
                    countDownLatch.countDown();
                }

            });
        }
        for (int i = 0; i <lists.size(); i++){
            service.execute(threadArray[i]);
        }
        //当子线程执行完毕时,主线程再往下执行
        countDownLatch.await();
        System.out.println("添加完毕");
    }catch (Exception e){
        log.info("error",e);
        throw new ServiceException("002","出现异常");
    }finally {
         connection.close();
     }
}

数据库中存在一条数据：

//测试用例
@RunWith(SpringRunner.class)
@SpringBootTest(classes = { ThreadTest01.class, MainApplication.class})
public class ThreadTest01 {

    @Resource
    private EmployeeBO employeeBO;

    /**
     *   测试多线程事务.
     * @throws InterruptedException
     */
    @Test
    public  void MoreThreadTest2() throws InterruptedException {
        int size = 10;
        List<EmployeeDO> employeeDOList = new ArrayList<>(size);
        for (int i = 0; i<size;i++){
            EmployeeDO employeeDO = new EmployeeDO();
            employeeDO.setEmployeeName("lol"+i);
            employeeDO.setAge(18);
            employeeDO.setGender(1);
            employeeDO.setIdNumber(i+"XX");
            employeeDO.setCreatTime(Calendar.getInstance().getTime());
            employeeDOList.add(employeeDO);
        }
        try {
            employeeBO.saveThread(employeeDOList);
            System.out.println("添加成功");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试结果：

可以发现子线程组执行时，有一个线程执行失败，其他线程也会抛出异常，但是主线程中执行的删除操作，没有回滚，@Transactional注解没有生效。


使用sqlSession控制手动提交事务





 @Resource
  SqlContext sqlContext;
 /**
 * 测试多线程事务.
 * @param employeeDOList
 */
@Override
public void saveThread(List<EmployeeDO> employeeDOList) throws SQLException {
    // 获取数据库连接,获取会话(内部自有事务)
    SqlSession sqlSession = sqlContext.getSqlSession();
    Connection connection = sqlSession.getConnection();
    try {
        // 设置手动提交
        connection.setAutoCommit(false);
        //获取mapper
        EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
        //先做删除操作
        employeeMapper.delete(null);
        //获取执行器
        ExecutorService service = ExecutorConfig.getThreadPool();
        List<Callable<Integer>> callableList  = new ArrayList<>();
        //拆分list
        List<List<EmployeeDO>> lists=averageAssign(employeeDOList, 5);
        AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        for (int i =0;i<lists.size();i++){
            if (i==lists.size()-1){
                atomicBoolean.set(false);
            }
            List<EmployeeDO> list  = lists.get(i);
            //使用返回结果的callable去执行,
            Callable<Integer> callable = () -> {
                //让最后一个线程抛出异常
                if (!atomicBoolean.get()){
                    throw new ServiceException("001","出现异常");
                }
              return employeeMapper.saveBatch(list);
            };
            callableList.add(callable);
        }
        //执行子线程
       List<Future<Integer>> futures = service.invokeAll(callableList);
        for (Future<Integer> future:futures) {
        //如果有一个执行不成功,则全部回滚
            if (future.get()<=0){
                connection.rollback();
                 return;
            }
        }
        connection.commit();
        System.out.println("添加完毕");
    }catch (Exception e){
        connection.rollback();
        log.info("error",e);
        throw new ServiceException("002","出现异常");
    }finally {
         connection.close();
     }
}
// sql
<insert id="saveBatch" parameterType="List">
 INSERT INTO
 employee (employee_id,age,employee_name,birth_date,gender,id_number,creat_time,update_time,status)
 values
     <foreach collection="list" item="item" index="index" separator=",">
     (
     #{item.employeeId},
     #{item.age},
     #{item.employeeName},
     #{item.birthDate},
     #{item.gender},
     #{item.idNumber},
     #{item.creatTime},
     #{item.updateTime},
     #{item.status}
         )
     </foreach>
 </insert>

数据库中一条数据：

测试结果：抛出异常，

删除操作的数据回滚了，数据库中的数据依旧存在，说明事务成功了。

成功操作示例：

 @Resource
SqlContext sqlContext;
/**
 * 测试多线程事务.
 * @param employeeDOList
 */
@Override
public void saveThread(List<EmployeeDO> employeeDOList) throws SQLException {
    // 获取数据库连接,获取会话(内部自有事务)
    SqlSession sqlSession = sqlContext.getSqlSession();
    Connection connection = sqlSession.getConnection();
    try {
        // 设置手动提交
        connection.setAutoCommit(false);
        EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
        //先做删除操作
        employeeMapper.delete(null);
        ExecutorService service = ExecutorConfig.getThreadPool();
        List<Callable<Integer>> callableList  = new ArrayList<>();
        List<List<EmployeeDO>> lists=averageAssign(employeeDOList, 5);
        for (int i =0;i<lists.size();i++){
            List<EmployeeDO> list  = lists.get(i);
            Callable<Integer> callable = () -> employeeMapper.saveBatch(list);
            callableList.add(callable);
        }
        //执行子线程
       List<Future<Integer>> futures = service.invokeAll(callableList);
        for (Future<Integer> future:futures) {
            if (future.get()<=0){
                connection.rollback();
                 return;
            }
        }
        connection.commit();
        System.out.println("添加完毕");
    }catch (Exception e){
        connection.rollback();
        log.info("error",e);
        throw new ServiceException("002","出现异常");
       // throw new ServiceException(ExceptionCodeEnum.EMPLOYEE_SAVE_OR_UPDATE_ERROR);
    }
}

测试结果：

数据库中数据：

删除的删除了，添加的添加成功了，测试成功。

欢迎扫码加入儒猿技术交流群，每天晚上20:00都有Java面试、Redis、MySQL、RocketMQ、SpringCloudAlibaba、Java架构等技术答疑分享，更能跟小伙伴们一起交流技术

另外推荐儒猿课堂的9.9元系列课程给您，欢迎加入一起学习~

互联网Java工程师面试突击课
（9.9元专享）
SpringCloudAlibaba零基础入门到项目实战
（9.9元专享）
亿级流量下的电商详情页系统实战项目
（9.9元专享）
Kafka消息中间件内核源码精讲
（9.9元专享）
12个实战案例带你玩转Java并发编程
（9.9元专享）
Elasticsearch零基础入门到精通
（9.9元专享）
基于Java手写分布式中间件系统实战
（9.9元专享）
基于ShardingSphere的分库分表实战课
（9.9元专享）

文章推荐

相关阅读

  • ChatGpt实现的短消息发送Redis限流功能

  • 「 关注“石杉的架构笔记”，大厂架构经验倾囊相授 」文章来源：【公众号：业余草】前言ChatGpt实现的短信发送Redis限流功能本文的内容和源码都来自于 ChatGpt，大家感受一下 ChatG

  • 7min 到 40s：SpringBoot 启动优化实践！

  • 关注我，回复关键字“spring”，免费领取Spring学习资料。来源：https://juejin.cn/post/71813425237285929550 背景公司 SpringBoot 项目在日常开发过程中发现服务启动过程异常缓

  • 柔性事务的分布式事务解决方案设计探究

  • 关注我，回复关键字“spring”，免费领取Spring学习资料。来源 | OSCHINA 社区作者 | 京东云开发者-郑朋辉原文链接：https://my.oschina.net/u/4090830/blog/55859631 背景市面上

  • Spring Boot中一个注解优雅实现重试

  • 关注我，回复关键字“spring”，免费领取Spring学习资料。重试，在项目需求中是非常常见的，例如遇到网络波动等，要求某个接口或者是方法可以最多/最少调用几次；实现重试机制，非得用Ret

  • Spring Boot 项目鉴权的 4 种方式

  • 关注我，回复关键字“spring”，免费领取Spring学习资料。文章介绍了spring-boot中实现通用auth的四种方式，包括 传统AOP、拦截器、参数解析器和过滤器，并提供了对应的实例代码，最

  • Spring Boot配置保存日志文件

  • 关注我，回复关键字“spring”，免费领取Spring学习资料。springboot日志配置：springboot默认日志是打印再console中的，不会保存在文件中。我们项目上线肯定要保存日志用于分析的

  • “兵心 兵情”演出慰问退役军人

  • “过去你们戎马一生，为国家经济建设和国防事业作出了重要贡献，是党和国家的宝贵财富，如今你们离开部队，相聚海淀，希望你们把海淀作为第二故乡，热爱海淀、关心海淀、建设海淀……”

  • 又有城市设立“人才日”，还要思考什么？

  • 文|朱晓帆继宁波、南通、温州之后，又一座城市以法定形式为人才设立了专属的节日。　湖州市景观 新华网发 4月24日，浙江湖州市人大常委会会议表决通过《关于设立“湖州人才日”

  • 审计费5000万！中国石油续聘会计师事务所！

  • 版权声明会计雅苑-会计审计资讯平台。本文来自公司公告，由会计雅苑收集整理，如需转载请注明来源。中国石油天然气股份有限公司（以下简称公司）拟继续聘用普华永
    道中天会计师事

聚合标签

中国 自己的 美国 都是 亿元 的人 疫情 的是 三星 手机 华为 企业 万元 这款 车型 日本 小米 俄罗斯 项目 民警

热门文章

  • “复活”半年后　京东拍拍二手杀入公益事业

  • 京东拍拍二手“复活”半年后，杀入公益事业，试图让企业捐的赠品、家庭闲置品变成实实在在的“爱心”。 把“闲置品”变爱心 6月12日，“益心一益·守护梦想每一步”2018年四

  • 美国对华2000亿关税清单，到底影响有多大？

  • 1 今天A股大跌，上证最大跌幅超过2%。直接导火索是美国证实计划对华2000亿美元产品加征25%关税。 听起来，2000亿美元数目巨大，我们来算笔账。 2000亿美元，按现在人民币汇率

最新文章

  • 2w 字带你实战 ElasticSearch！

  • 原价199元，现在参加拼团活动立享优惠价仅 99 元，赶快一起参团吧！《百万数据量下的高性能商品搜索系统实战》=== 课程福利 ===为了让更多同学学到赚到，《百万数据量下的高性能商

  • 被坑惨了！盘点Kafka一些非比寻常的坑！

  • 原价299元，现在参加拼团活动立享优惠价仅 149 元，赶快一起参团吧！《Kafka架构设计与内核源码深度剖析》=== 课程背景 ===无论在跳槽面试还是实际工作中，Kafka都是必不可少的一环