关于java:支付宝一面多线程事务怎么回滚说用-Transactional-可以回去等通知了

59次阅读

共计 6881 个字符，预计需要花费 18 分钟才能阅读完成。

背景介绍

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();}
}

举荐一个 Spring Boot 基础教程及实战示例：https://github.com/javastacks/spring-boot-best-practice

示例事务不胜利操作

  /**
 * 测试多线程事务.
 * @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();
     }
}

数据库中存在一条数据：

Spring Boot 根底就不介绍了，举荐下这个实战教程：
https://github.com/javastacks/spring-boot-best-practice

// 测试用例
@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);
    }
}

测试后果：

数据库中数据：

删除的删除了，增加的增加胜利了，测试胜利。

版权申明：本文为 CSDN 博主「weixin_43225491」的原创文章，遵循 CC 4.0 BY-SA 版权协定，转载请附上原文出处链接及本申明。原文链接：https://blog.csdn.net/weixin_43225491/article/details/117705686

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2023-09-22
 0
Spring-security-一架构框架ComponentServiceFilter分析
关于java:Java-Web企业项目实战pdf
关于java:线程池是如何重复利用空闲线程的
Java中的集合类ListSetMap