文章展示了在JavaSpring环境下，如何在多线程场景下进行事务管理。通过创建一个`TransactionalUntil`类来获取、提交和回滚事务，并在测试代码中使用`CountDownLatch`来协调两个并发执行的线程，确保在所有子线程完成后，根据执行结果决定事务是提交还是回滚。
业务背景
工作中有很多，在一个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();
}
扫一扫
195
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
