0
0

Mybatis-plus更新多张表,保证事务安全的情况下使用异步多线程实现(待验证)

Mybatis-plus更新多张表,保证事务安全的情况下使用异步多线程实现(待验证)

文章目录

方案一:

importcom.baomidou.mybatisplus.core.conditions.query.QueryWrapper;importcom.baomidou.mybatisplus.core.toolkit.Wrappers;importcom.baomidou.mybatisplus.extension.service.IService;importlombok.extern.slf4j.Slf4j;importjava.util.List;importjava.util.concurrent.CompletableFuture;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;/**
 * 使用mybatis-plus更新多张表，如何使用异步多线程更新多张表，并且保证事务安全
 *
 * @author hubin
 * @since 2018-08-20
 */@Slf4jpublicclassAsyncUpdateMultiTableExample{publicstaticvoidmain(String[] args){// 创建线程池ExecutorService executorService =Executors.newFixedThreadPool(10);// 创建service对象IService<User> userService =newUserServiceImpl();// 创建查询条件QueryWrapper<User> queryWrapper =Wrappers.query();
        queryWrapper.eq("id",1);// 查询数据List<User> users = userService.list(queryWrapper);// 使用异步多线程更新数据CompletableFuture.allOf(users.stream().map(user ->{returnCompletableFuture.runAsync(()->{// 更新数据
                userService.updateById(user);}, executorService);}).toArray(CompletableFuture[]::new)).join();// 关闭线程池
        executorService.shutdown();}/**
     * 用户表
     */publicstaticclassUser{privateLong id;privateString name;privateInteger age;publicLonggetId(){return id;}publicvoidsetId(Long id){this.id = id;}}

要使用异步多线程更新多张表并保证事务安全，可以使用Spring框架的异步处理和事务管理功能。下面是一个简单的示例：

  1. 首先，需要在Spring配置文件中启用异步处理和事务管理。可以使用以下配置：
<task:annotation-drivenexecutor="asyncExecutor"/><task:executorid="asyncExecutor"pool-size="10"/><tx:annotation-driven/>
  1. 在Java代码中，可以使用@Async注解将方法标记为异步方法。在异步方法中，可以使用@Transactional注解来启用事务管理。例如：
@ServicepublicclassMyService{@AutowiredprivateMyMapper1 myMapper1;@AutowiredprivateMyMapper2 myMapper2;@Async@TransactionalpublicvoidupdateMultipleTables(){// 更新第一个表 
        myMapper1.updateTable1();// 更新第二个表 
        myMapper2.updateTable2();// 如果有其他需要更新的表，可以继续添加相应的代码 }}
  1. 在调用异步方法时，可以使用Spring的AsyncTaskExecutor来执行异步任务。例如：
@ServicepublicclassMyOtherService{@AutowiredprivateMyService myService;@AutowiredprivateAsyncTaskExecutor asyncTaskExecutor;publicvoiddoUpdate(){// 异步执行多个表的更新操作 
        asyncTaskExecutor.submit(()-> myService.updateMultipleTables()).get();}}

在上面的代码中，

submit()

方法将异步任务提交给

asyncTaskExecutor

执行，

get()

方法等待异步任务完成。由于异步任务使用了

@Transactional

注解，因此在异步任务中的所有数据库操作都将在一个事务中执行，保证了事务的完整性和一致性。

需要注意的是，异步任务的执行可能会影响系统的性能和稳定性。因此，需要根据具体的情况进行评估和优化。

方案二:

在使用mybatis-plus更新多张表时，可以使用异步多线程的方式来提高效率。以下是一个简单的实例，演示如何使用异步多线程更新多张表，并确保事务安全。

示例代码：

@ServicepublicclassUpdateService{@AutowiredprivateAsyncService asyncService;@AutowiredprivateTransactionTemplate transactionTemplate;publicvoidupdateMultipleTables(UpdateRequest request){
        transactionTemplate.execute(newTransactionCallbackWithoutResult(){@OverrideprotectedvoiddoInTransactionWithoutResult(TransactionStatus status){
                asyncService.updateTableA(request.getTableAData());
                asyncService.updateTableB(request.getTableBData());
                asyncService.updateTableC(request.getTableCData());}});}}@ServicepublicclassAsyncService{@AutowiredprivateTableAService tableAService;@AutowiredprivateTableBService tableBService;@AutowiredprivateTableCService tableCService;@AsyncpublicvoidupdateTableA(TableAData data){
        tableAService.update(data);}@AsyncpublicvoidupdateTableB(TableBData data){
        tableBService.update(data);}@AsyncpublicvoidupdateTableC(TableCData data){
        tableCService.update(data);}}

在上面的代码中，

UpdateService

是一个服务类，用于协调多个异步更新操作，并确保它们在同一事务中执行。

AsyncService

是一个异步服务类，用于实际执行每个异步更新操作。

在 

UpdateService

中，使用 

TransactionTemplate

来启用事务，并在事务中调用异步服务类中的更新方法。由于更新方法被标记为异步，因此它们将在一个独立的线程中执行。

在 

AsyncService

中，每个更新方法都被标记为异步，并且使用相应的服务类来执行实际的更新操作。

注意，

@Async

标注了每个更新方法，这意味着每个更新操作将在独立的线程中执行。因此，我们需要确保每个更新方法都是线程安全的，并且能够在多个线程之间正确地共享数据。

总之，使用异步多线程更新多张表可以提高系统的并发处理能力和效率。而使用事务模板可以确保多个更新操作在同一个事务中执行，从而保证了事务安全。 ```

方案三:使用mybatis-plus更新数据库的五张不同的表,开启五个线程，每个线程负责更新一张表，如何在保证事务和线程安全的情况下，做到异步更新，编写详细的示例，并详细说明

在使用多线程更新多张表时，需要注意以下几个方面：

  1. 保证事务安全：多个线程操作多张表需要保证事务的一致性，即要么所有表的更新操作都成功，要么所有表的更新操作都失败。因此，在多个线程中，需要使用同一个事务管理器，并且在事务范围内执行更新操作。
  2. 保证线程安全：在多线程环境下，多个线程并发地更新同一张表可能会导致数据不一致。因此，在更新操作时，需要使用线程同步机制，例如使用synchronized关键字或者Lock接口。
  3. 优化性能：使用线程池可以有效地减少线程的创建和销毁，提高程序的性能。

下面是一个使用mybatis-plus更新五张不同表的示例代码：

@ServicepublicclassUpdateService{@AutowiredprivateTransactionTemplate transactionTemplate;@AutowiredprivateThreadPoolTaskExecutor taskExecutor;@AutowiredprivateTable1Mapper table1Mapper;@AutowiredprivateTable2Mapper table2Mapper;@AutowiredprivateTable3Mapper table3Mapper;@AutowiredprivateTable4Mapper table4Mapper;@AutowiredprivateTable5Mapper table5Mapper;publicvoidupdateAllTables(){// 开启事务
        transactionTemplate.execute(newTransactionCallbackWithoutResult(){@OverrideprotectedvoiddoInTransactionWithoutResult(TransactionStatus transactionStatus){// 使用线程池异步更新五张表
                taskExecutor.execute(()->updateTable1());
                taskExecutor.execute(()->updateTable2());
                taskExecutor.execute(()->updateTable3());
                taskExecutor.execute(()->updateTable4());
                taskExecutor.execute(()->updateTable5());}});}privatesynchronizedvoidupdateTable1(){// 更新表1
        table1Mapper.updateById(newTable1());}privatesynchronizedvoidupdateTable2(){// 更新表2
        table2Mapper.updateById(newTable2());}privatesynchronizedvoidupdateTable3(){// 更新表3
        table3Mapper.updateById(newTable3());}privatesynchronizedvoidupdateTable4(){// 更新表4
        table4Mapper.updateById(newTable4());}privatesynchronizedvoidupdateTable5(){// 更新表5
        table5Mapper.updateById(newTable5());}}

在上述代码中，我们使用了TransactionTemplate和ThreadPoolTaskExecutor来保证事务和线程安全。在updateAllTables方法中，我们使用TransactionTemplate开启事务，并使用线程池异步更新五张表。在每个更新方法中，使用synchronized关键字来保证线程安全。

需要注意的是，在使用线程池时，线程池的大小需要根据系统的实际情况进行调整，以避免线程池过大或过小导致的性能问题。 ```

方案四:

importcom.baomidou.mybatisplus.core.conditions.query.QueryWrapper;importcom.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;importcom.baomidou.mybatisplus.core.metadata.IPage;importcom.baomidou.mybatisplus.core.toolkit.Wrappers;importcom.baomidou.mybatisplus.extension.service.IService;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.stereotype.Service;importjava.util.concurrent.CountDownLatch;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;@ServicepublicclassUserService{@AutowiredprivateUserMapper userMapper;publicvoidupdateUser(int userId,String userName){UpdateWrapper<User> updateWrapper =newUpdateWrapper<>();
    updateWrapper.eq("user_id", userId);
    updateWrapper.set("user_name", userName);
    userMapper.update(null, updateWrapper);}publicvoidtestAsyncUpdate()throwsInterruptedException{// 创建一个 CountDownLatch 对象，并设置计数器为 5CountDownLatch countDownLatch =newCountDownLatch(5);// 创建一个线程池ExecutorService executorService =Executors.newFixedThreadPool(5);// 启动 5 个线程，每个线程负责更新一张表for(int i =0; i <5; i++){
        executorService.submit(()->{// 获取当前线程的 idint threadId =Thread.currentThread().getId();// 获取要更新的表名String tableName ="user_"+ threadId;// 创建一个 QueryWrapper 对象QueryWrapper<User> queryWrapper =newQueryWrapper<>();// 设置查询条件
            queryWrapper.eq("user_id", threadId);// 查询数据User user = userMapper.selectOne(queryWrapper);// 更新数据updateUser(threadId, user.getUserName()+"_update");// 计数器减一
            countDownLatch.countDown();});}// 等待所有线程执行完毕
    countDownLatch.await();// 关闭线程池
    executorService.shutdown();}}

在上述示例中，我们使用了 mybatis-plus 的 

QueryWrapper

和 

UpdateWrapper

对象来构建查询条件和更新条件。我们还使用了 

CountDownLatch

对象来等待所有线程执行完毕。

在保证事务和线程安全的情况下，做到异步更新，可以通过以下方式实现：

  1. 使用 synchronized 关键字来保证方法的线程安全。
  2. 使用 @Transactional 注解来开启事务。
  3. 使用 ExecutorService 来创建线程池。
  4. 使用 submit() 方法来启动线程。
  5. 使用 countDownLatch.await() 方法来等待所有线程执行完毕。
  6. 使用 countDownLatch.countDown() 方法来减小计数器

通过以上方式，我们可以保证事务和线程安全的情况下，做到异步更新。

方案五:

importcom.baomidou.mybatisplus.core.conditions.query.QueryWrapper;importcom.baomidou.mybatisplus.core.metadata.IPage;importcom.baomidou.mybatisplus.extension.service.IService;importcom.google.common.util.concurrent.CompletableFuture;importorg.springframework.transaction.annotation.Transactional;importjava.util.List;importjava.util.concurrent.ExecutionException;publicclassMybatisPlusAsyncUpdateExample{privatestaticfinalStringNAMESPACE="com.example.mybatisplus.mapper.UserMapper";@Transactionalpublicstaticvoidmain(String[] args)throwsExecutionException,InterruptedException{// 创建五个线程，每个线程负责更新一张表List<CompletableFuture<Void>> futures =newArrayList<>();for(int i =0; i <5; i++){
            futures.add(updateAsync(i));}// 等待所有线程执行完成CompletableFuture.allOf(futures).join();}privatestaticCompletableFuture<Void>updateAsync(int tableIndex){returnCompletableFuture.runAsync(()->{// 获取 UserMapper 接口IService<User> userService =SpringContextHolder.getBean(NAMESPACE+".UserService");// 创建 QueryWrapper 对象QueryWrapper<User> queryWrapper =newQueryWrapper<>();
            queryWrapper.eq("id", tableIndex);// 更新数据
            userService.update(queryWrapper);});}staticclassUser{privateLong id;privateString name;}}

在上述示例中，我们使用了 CompletableFuture 来实现异步更新。CompletableFuture 是一个异步计算工具，它可以让我们以异步的方式执行任务，并在任务完成时获取结果。

在示例中，我们创建了五个 CompletableFuture 对象，每个 CompletableFuture 对象对应一个线程，每个线程负责更新一张表。我们使用 CompletableFuture.allOf() 方法等待所有线程执行完成，然后再继续执行后续的代码。

这样，我们就实现了在保证事务和线程安全的情况下，做到异步更新。

方案六:

@Service@TransactionalpublicclassAsyncUpdateService{@AutowiredprivateTable1Mapper table1Mapper;@AutowiredprivateTable2Mapper table2Mapper;@AutowiredprivateTable3Mapper table3Mapper;@AutowiredprivateTable4Mapper table4Mapper;@AutowiredprivateTable5Mapper table5Mapper;publicvoidasyncUpdate(){CompletableFuture<Void> future1 =CompletableFuture.runAsync(()->{
            table1Mapper.updateTable1();});CompletableFuture<Void> future2 =CompletableFuture.runAsync(()->{
            table2Mapper.updateTable2();});CompletableFuture<Void> future3 =CompletableFuture.runAsync(()->{
            table3Mapper.updateTable3();});CompletableFuture<Void> future4 =CompletableFuture.runAsync(()->{
            table4Mapper.updateTable4();});CompletableFuture<Void> future5 =CompletableFuture.runAsync(()->{
            table5Mapper.updateTable5();});CompletableFuture.allOf(future1, future2, future3, future4, future5).join();}}

在这个示例中，我们使用了CompletableFuture.runAsync()方法来异步更新每张表。每个CompletableFuture都在自己的线程中执行，保证了线程安全性。同时，我们使用了CompletableFuture.allOf()方法来等待所有CompletableFuture完成，保证了事务的一致性。

需要注意的是，这个示例中使用了@Transactional注解来保证事务的一致性。如果在实际项目中使用，需要根据具体情况来选择是否需要事务。同时，需要根据具体情况来调整线程池的大小，以充分利用系统资源

标签： mybatis 安全
本文转载自: https://blog.csdn.net/LuckFairyLuckBaby/article/details/134980577
版权归原作者 烟火缠过客 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Mybatis-plus更新多张表,保证事务安全的情况下使用异步多线程实现(待验证)”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

鸿蒙HarmonyOS应用开发 | 从设计到优化HarmonyOS 助力打造高效、安全的移动办公应用

开源AI图片处理工具HivisionIDPhotos安装与证件照制作指南

基于大数据爬虫+协同过滤推荐算法+SpringBoot的计算机岗位推荐系统设计和实现(源码+论文+部署讲解等)

FlinkCDC支持人大金仓

Kafka

Hive使用与介绍

搭建.NET Core Web API 文件上传项目

文章导航