Springboot 多线程实现事务控制

李哈ha

已于 2024-03-28 09:45:06 修改

阅读量1.5k

点赞数 2

分类专栏： # 多线程文章标签： spring boot java spring

于 2023-04-28 15:10:37 首次发布

本文链接：https://blog.csdn.net/qq_43049310/article/details/130426553

版权

多线程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

业务背景

工作中有很多，在一个service实现层，有可能调用其他的service，或者说是使用异步线程，这样就不容易控制当前操作成功和失败
不多说，上代码

获取数据库事务控制器

@Component
public class TransactionalUntil {

    @Resource
    private DataSourceTransactionManager dataSourceTransactionManager;

    /**
     * 开启事务
     */
    public TransactionStatus begin() {
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transaction;
    }

    /**
     * 提交事务
     */
    public void commit(TransactionStatus transactionStatus) {
        dataSourceTransactionManager.commit(transactionStatus);
    }

    /**
     * 回滚事务
     */
    public void rollback(TransactionStatus transactionStatus) {
        dataSourceTransactionManager.rollback(transactionStatus);
    }

}

测试代码

package com.demo.easypdf;

import cn.hutool.core.thread.ThreadUtil;
import com.beust.jcommander.internal.Lists;
import com.demo.easypdf.domain.TestOne;
import com.demo.easypdf.domain.TestT;
import com.demo.easypdf.domain.User;
import com.demo.easypdf.mapper.TestOneMapper;
import com.demo.easypdf.mapper.TestTMapper;
import com.demo.easypdf.mapper.UserMapper;
import com.demo.easypdf.untils.TransactionalUntil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import wiki.xsx.core.pdf.component.text.XEasyPdfText;
import wiki.xsx.core.pdf.doc.XEasyPdfDocument;
import wiki.xsx.core.pdf.doc.XEasyPdfPage;
import wiki.xsx.core.pdf.handler.XEasyPdfHandler;
import wiki.xsx.core.pdf.template.doc.XEasyPdfTemplateDocument;
import wiki.xsx.core.pdf.template.doc.component.block.XEasyPdfTemplateBlockContainer;
import wiki.xsx.core.pdf.template.doc.component.image.XEasyPdfTemplateImage;
import wiki.xsx.core.pdf.template.doc.component.page.XEasyPdfTemplateCurrentPageNumber;
import wiki.xsx.core.pdf.template.doc.component.page.XEasyPdfTemplateTotalPageNumber;
import wiki.xsx.core.pdf.template.doc.component.text.XEasyPdfTemplateText;
import wiki.xsx.core.pdf.template.doc.page.XEasyPdfTemplatePage;
import wiki.xsx.core.pdf.template.handler.XEasyPdfTemplateHandler;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @Author: lkz
 * @Title: TestController
 * @Description: TODO
 * @Date: 2023/4/27 23:17
 */
@RestController
@Slf4j
public class TestController {

    @Resource
    private UserMapper userMapper;
    @Resource
    private TestOneMapper testOneMapper;
    @Resource
    private TestTMapper testTMapper;

    private volatile  Boolean is_ok=new Boolean(true);

    @Resource
    private TransactionalUntil transactionalUntil;

    @GetMapping("test2")
    public void testThreadTran(){
        // 监控子线程数据
        CountDownLatch childMonitor = new CountDownLatch(2);
        // 主线程收集子线程运行最终结果
        List<Boolean> childResponse= new CopyOnWriteArrayList<>();
        //子线程在该对象上等待主线程的通知
        CountDownLatch mainMonitor = new CountDownLatch(1);

        ThreadUtil.execAsync(()->{

            // 开启事务
            TransactionStatus transactionStatus = transactionalUntil.begin();
            try {
                // 操作数据库逻辑
                List<User> user = this.getUserList();
                userMapper.insert(user.get(0));
                childResponse.add(Boolean.TRUE);
                childMonitor.countDown();

                mainMonitor.await();
                log.info("user-线程{}正常执行结束,等待其他线程执行结束",Thread.currentThread().getName());
                if(is_ok){
                    // 事务提交
                    log.info("user-线程正常执行,线程事务提交",Thread.currentThread().getName());
                    transactionalUntil.commit(transactionStatus);
                }else{
                    // 事务回滚
                    log.info("user-线程执行出现异常,线程事务回滚",Thread.currentThread().getName());
                    transactionalUntil.rollback(transactionStatus);
                }
            }catch (Exception e){
                // 提交失败
                log.info("user-线程执行出现异常{},",Thread.currentThread().getName());
                childMonitor.countDown();
                childResponse.add(Boolean.FALSE);
                transactionalUntil.rollback(transactionStatus);
            }

        });

        ThreadUtil.execAsync(()->{
            // 开启事务
            TransactionStatus transactionStatus = transactionalUntil.begin();
            try {
                // 操作数据库逻辑
                List<TestT> testTList = this.getTestTList();
                testTMapper.insert(testTList.get(0));
                log.info("test-线程{}正常执行结束,等待其他线程执行结束",Thread.currentThread().getName());
                // 模拟异常
              //  int a=10/0;
                childResponse.add(Boolean.TRUE);
                childMonitor.countDown();
                mainMonitor.await();
                if(is_ok){
                    // 事务提交
                    log.info("test-线程正常执行,线程事务提交",Thread.currentThread().getName());
                    transactionalUntil.commit(transactionStatus);
                }else{
                    // 事务回滚
                    log.info("test-线程执行出现异常,线程事务回滚",Thread.currentThread().getName());
                    transactionalUntil.rollback(transactionStatus);
                }
            }catch (Exception e){
                // 提交失败
                log.info("test-线程执行出现异常{},",Thread.currentThread().getName());
                childMonitor.countDown();
                childResponse.add(Boolean.FALSE);
                transactionalUntil.rollback(transactionStatus);
            }
        });

        try {
            childMonitor.await();
            for(Boolean res:childResponse){
                while (!res){
                    // 如果有一个子线程只想失败，改变mainResult状态 事务回滚
                    log.info("有线程执行失败,修改标识位,事务回滚");
                    is_ok=false;
                    break;
                }
            }
            //主线程获取结果，子线程根据主线程的结果 提交或回滚
            mainMonitor.countDown();
            System.out.println("执行结束-------");
        }catch (Exception e){
            log.info("事务执行失败");
        }

    }


    public List<User> getUserList(){
        List<User> users= Lists.newArrayList();
        for(int i=0;i<20;i++){
            User user = new User();
            user.setId(i);
            user.setUsername("小"+i);
            user.setPassword("asc");
            user.setAge(i+0);
            users.add(user);
        }
        return users;
    }

    public List<TestT> getTestTList(){
        List<TestT> TestT= Lists.newArrayList();
        for(int i=0;i<20;i++){
            TestT tt = new TestT();
            tt.setPhone("i"+"-1234537");
            tt.setId(i);
            TestT.add(tt);
        }
        return TestT;
    }
    public List<TestOne> getTestOneList(){
        List<TestOne> oneList= Lists.newArrayList();
        for(int i=0;i<20;i++){
            TestOne tt = new TestOne();
            tt.setName("i"+"-1234537");
            oneList.add(tt);
        }
        return oneList;
    }

}

测试结果

没有异常

表1
在这里插入图片描述
表二

控制台打印

模拟异常

控制台
在这里插入图片描述
数据库无新增

题外补充：

 // 异步添加 数据
        List<CompletableFuture> futures=new ArrayList<>();
        InheritableThreadLocal threadLocal = new InheritableThreadLocal();
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            TransactionStatus begin = transactionalUntil.begin();
            threadLocal.set(begin);
            List<CtmsCore> ctmsCores = coreMapper.selectList(new LambdaQueryWrapper<CtmsCore>().eq(CtmsCore::getProjectId, batchEntry.getProjectId())
                    .eq(CtmsCore::getIsStatus, NumEnums.THREE.getType()));
            if (CollUtil.isNotEmpty(ctmsCores)) {
                List<CtmsProjectCoreUseLandmark> batchData = new ArrayList<>();
                for (CtmsCore core : ctmsCores) {
                    StringBuffer buffer = new StringBuffer();
                    int thisSecond = DateUtil.thisSecond();
                    int millisecond = DateUtil.thisMillisecond();
                    buffer.append(String.valueOf(thisSecond)).append(String.valueOf(millisecond));
                    coreLandmarks.forEach(mark -> {
                        CtmsProjectCoreUseLandmark useLandmark = new CtmsProjectCoreUseLandmark();
                        useLandmark.setProjectId(mark.getProjectId());
                        useLandmark.setCoreId(core.getId());
                        useLandmark.setLandmarkName(mark.getLandmarkName());
                        useLandmark.setStage(mark.getStage());
                        useLandmark.setSort(mark.getSort());
                        useLandmark.setWeight(mark.getWeight());
                        useLandmark.setIsBeginNode(mark.getIsBeginNode());
                        useLandmark.setId(mark.getId() + buffer+core.getCoreCode());
                        useLandmark.setTemplateId(mark.getTemplatePlanId());
                        useLandmark.setCoreLandmarkId(mark.getId());
                        if (!mark.getParentId().equals(NumEnums.ZERO.getType()) && StrUtil.isNotEmpty(mark.getParentId())) {
                            useLandmark.setParentId(mark.getParentId() + format + buffer+core.getCoreCode());
                        }
                        batchData.add(useLandmark);
                    });

                }
                if (CollUtil.isNotEmpty(batchData)) {
                    coreUseLandmarkMapper.insertBatch(batchData);
                }

                transactionalUntil.commit(begin);

            }
        }).exceptionally((a) -> {
            if(Objects.nonNull(a)){
                TransactionStatus transactionStatus = (TransactionStatus)threadLocal.get();
                transactionalUntil.rollback(transactionStatus);
            }
            throw ServiceExceptionUtil.exception(new ErrorCode(9999, "应用中心里程碑失败"));

        });
        futures.add(future);
        for(CompletableFuture future1:futures){
            future1.join();
        }