多线程异常 和 事务(二)

最新推荐文章于 2024-02-23 16:43:03 发布
最新推荐文章于 2024-02-23 16:43:03 发布
阅读量2.1k 收藏 1
点赞数 1
分类专栏： java多线程 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WeiJiaXiaoBao/article/details/51218031
版权

1.接着上一篇代码变形一下

首先我们在上一篇文章的基础上把代码变形的面向对象一些

package com.wei.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

public class MultiThreadExceptionAndReturnValSHow {

	public static void main(String[] args) {
		final ThreadFactory threadFactory = new ThreadFactoryBuilder()
				.setNameFormat("Orders-%d-Thread:").build();

		int minPoolSize = 5;
		int maxPoolSize = 10;

		//SynchronousQueue同步队列容量0,就是说线程池没有等待队列
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
				minPoolSize, maxPoolSize, 60L, TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>(), threadFactory);

		//测试一个Runnable
		for (int i = 0; i < 5; i++) {
			ExceptionRunThread thread = new ExceptionRunThread();
			threadPoolExecutor.submit(thread);
		}
		//测试一个callable
		for (int i = 0; i < 5; i++) {
			ExceptionCallableThread call = new ExceptionCallableThread();
			threadPoolExecutor.submit(call);
		}
		//测试多个callable
		List<Callable<String>> callList = new ArrayList<Callable<String>>();
		for (int i = 0; i < 5; i++) {
			ExceptionCallable call = new ExceptionCallable();
			callList.add(call);
		}
		invokeAllTask(threadPoolExecutor, callList);
		//等待任务完成后，关闭线程池
		threadPoolExecutor.shutdown();
	}

	private static <T> List<T> invokeAllTask(
			ThreadPoolExecutor threadPoolExecutor, List<Callable<T>> callList) {
		List<Future<T>> futureAll = null;
		List<T> resultList = new ArrayList<T>();
		try {
			futureAll = threadPoolExecutor.invokeAll(callList);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		AtomicInteger in = new AtomicInteger(1);
		for (Future<T> f : futureAll) {
			try {
				T result = f.get();
				System.out.println("count:" + in.getAndIncrement() + ":"
						+ result);
				resultList.add(result);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		return resultList;
	}

}

class ExceptionRunThread implements Runnable {

	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()
					+ "do something start......");
			if (Thread.currentThread().getName().contains("2")) {
				throw new RuntimeException("测试 uncheck exception");
			}
			Thread.sleep(100);// do something
			System.out.println(Thread.currentThread().getName()
					+ "do something end......");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class ExceptionCallableThread implements Callable<String> {

	@Override
	public String call() {
		try {
			System.out.println(Thread.currentThread().getName()
					+ "do something start......");
			if (Thread.currentThread().getName().contains("2")) {
				throw new RuntimeException("测试 uncheck exception");
			}
			Thread.sleep(100);// do something
			System.out.println(Thread.currentThread().getName()
					+ "do something end......");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return Thread.currentThread().getName();
	}
}


这里面有有一个重要的地方，就是线程的命名，我们借助google线程工厂的一个类，线程的命名很重要，大家可以把线程数量修改到20，
Run结果

Orders-0-Thread:do something start......
Orders-1-Thread:do something start......
Orders-2-Thread:do something start......
Orders-3-Thread:do something start......
Orders-4-Thread:do something start......
Orders-5-Thread:do something start......
Orders-6-Thread:do something start......
Orders-7-Thread:do something start......
Orders-8-Thread:do something start......
Orders-9-Thread:do something start......
Orders-10-Thread:do something start......
Orders-11-Thread:do something start......
Orders-12-Thread:do something start......
Orders-13-Thread:do something start......
Orders-14-Thread:do something start......
Orders-0-Thread:do something end......
Orders-1-Thread:do something end......
Orders-4-Thread:do something end......
Orders-3-Thread:do something end......
Orders-6-Thread:do something end......
Orders-5-Thread:do something end......
Orders-8-Thread:do something end......
Orders-7-Thread:do something end......
Orders-9-Thread:do something end......
Orders-14-Thread:do something end......
Orders-11-Thread:do something end......
Orders-10-Thread:do something end......
Orders-13-Thread:do something end......
count:1:Orders-10-Thread:
count:2:Orders-11-Thread:
java.util.concurrent.ExecutionException: java.lang.RuntimeException: 测试 uncheck exception
	at java.util.concurrent.FutureTask$Sync.innerGet(Unknown Source)
	at java.util.concurrent.FutureTask.get(Unknown Source)
	at com.wei.service.impl.MultiThreadExceptionAndReturnValSHow.invokeAllTask(MultiThreadExceptionAndReturnValSHow.java:63)
	at com.wei.service.impl.MultiThreadExceptionAndReturnValSHow.main(MultiThreadExceptionAndReturnValSHow.java:46)
Caused by: java.lang.RuntimeException: 测试 uncheck exception
	at com.wei.service.impl.ExceptionCallable.call(MultiThreadExceptionAndReturnVal.java:138)
	at com.wei.service.impl.ExceptionCallable.call(MultiThreadExceptionAndReturnVal.java:1)
	at java.util.concurrent.FutureTask$Sync.innerRun(Unknown Source)
	at java.util.concurrent.FutureTask.run(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
count:3:Orders-13-Thread:
count:4:Orders-14-Thread:

输出不难理解，线程2和12线程都没有正常结束，而线程12正好运行的是有返回值的所以count:5:orders-12-Thread是异常的。

2下面我们集成到spring中去看，有了上面的代码变形，那么集成到spring中会比较容易

先看线程池业务接口类 
package com.wei.service;

import java.util.List;
import java.util.concurrent.Callable;

import com.wei.service.facade.vo.CommonResonse;

public interface MultiThreadTaskExecutorService {

	public <T> CommonResonse<T> invokeAll(List<Callable<T>> taskList);
}
实现类，我们可以看到线程执行器被包在了这个里面 
package com.wei.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

import com.alibaba.fastjson.JSON;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.wei.service.MultiThreadTaskExecutorService;
import com.wei.service.facade.vo.CommonResonse;


public class MultiThreadTaskExecutorServiceImpl implements
		MultiThreadTaskExecutorService, InitializingBean, DisposableBean {

	private Logger logger = LoggerFactory.getLogger(this.getClass());
	private ThreadPoolExecutor threadPoolExecutor;
	private int minPoolSize;
	private int maxPoolSize;

	@Override
	public <T> CommonResonse<T> invokeAll(List<Callable<T>> taskList) {
		try {
			List<Future<T>> futures = threadPoolExecutor.invokeAll(taskList);
			List<T> resultList = new ArrayList<T>();
			for (Future<T> future : futures) {
				try {
					resultList.add(future.get());
				} catch (ExecutionException e) {
					e.printStackTrace();
				}
			}
			logger.info("result={}",JSON.toJSONString(resultList));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public void destroy() throws Exception {
		threadPoolExecutor.shutdown();
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		final ThreadFactory threadFactory = new ThreadFactoryBuilder()
        .setNameFormat("Orders-%d")
        .build();
		threadPoolExecutor = new ThreadPoolExecutor(minPoolSize, maxPoolSize,
				60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),threadFactory);
	}

	public int getMinPoolSize() {
		return minPoolSize;
	}

	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}

	public int getMaxPoolSize() {
		return maxPoolSize;
	}

	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}

}


xm里bean的配置 
	<bean id="multiThreadTaskExecutorService"
		class="com.wei.service.impl.MultiThreadTaskExecutorServiceImpl">
		<property name="minPoolSize" value="5" />
		<property name="maxPoolSize" value="10" />
	</bean>

aop事务的配置 
<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="*" propagation="REQUIRED" rollback-for="java.lang.Exception"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<aop:pointcut id="servicePiontCut"
			expression="execution(* com.wei.service..*(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="servicePiontCut" />
	</aop:config>


在看业务接口类 
package com.wei.service;

import java.util.List;
import java.util.concurrent.Callable;

import com.wei.dao.entity.User;


public interface CallTaskService extends Callable<List<User>>{

	List<User> call();
}


package com.wei.service;

import java.util.List;
import java.util.concurrent.Callable;

import com.wei.dao.entity.User;


public interface CallTask2Service extends Callable<List<User>>{

	List<User> call();
}


业务接口实现 
package com.wei.service.impl;

import java.util.List;
import java.util.concurrent.Callable;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.wei.dao.entity.User;
import com.wei.dao.mapper.UserMapper;
import com.wei.service.CallTaskService;

@Service
public class CallTaskServiceImpl implements CallTaskService ,Callable<List<User>>{


	@Autowired
	UserMapper userMapper;
	
	@Override
	public List<User> call() {
		return userMapper.select(null);
	}
}

下面是依赖这几个接口的测试类，接口没有写大家自己补一下 
package com.wei.service.impl;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;

import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wei.dao.entity.User;
import com.wei.dao.mapper.UserMapper;
import com.wei.service.CallTask2Service;
import com.wei.service.CallTaskService;
import com.wei.service.MultiThreadTaskExecutorService;
import com.wei.service.UserService;
import com.wei.service.vo.UserVo;

@Service
public class UserServiceImpl implements UserService{

	@Autowired
	UserMapper userMapper;
	@Autowired
	CallTask2Service callTask2Service;
	@Autowired
	CallTaskService callTaskService;
	@Autowired
	MultiThreadTaskExecutorService multiThreadTaskExecutorService;
	
	@Override
	public void testThreadRollBack(UserVo userVo) {
		List<Callable<List<User>>> taskList=new ArrayList<Callable<List<User>>>();
//		taskList.add(new Callable<List<User>>() {
//			@Override
//			public List<User> call() throws Exception {
//				System.out.println("---------->"+"select");
//				return userMapper.select(null);
//			}
//		});
//		taskList.add(new Callable<List<User>>() {
//			@Override
//			public List<User> call() throws Exception {
//				User user=new User();
//				user.setCreateDate(new Date());
//				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//				user.setId("rollbank20160421-"+sdf.format(new Date()));
//				user.setName("rollback"+sdf.format(new Date()));
//				user.setPassword("2222222");
//				userMapper.insert(user);
//				System.out.println("---------->"+"insert and select");
//				userMapper.select(null);
//				int i=1/0;
//				return userMapper.select(null);
//			}
//		});
		taskList.add(callTask2Service);
		taskList.add(callTaskService);
		multiThreadTaskExecutorService.invokeAll(taskList);
//		User user=new User();
//		user.setCreateDate(new Date());
//		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//		user.setId("rollbank20160421-"+sdf.format(new Date()));
//		user.setName("rollback"+sdf.format(new Date()));
//		user.setPassword("11111111");
//		userMapper.insert(user);
		int i=1/0;
	}

}

通过测试，结果我就不贴出来了，我们可以看到只要是spring托管的bean切面的事务就是起作用的，new的就没有事务，runnable和callable也一样，new出来的匿名内部类spring不管理他的事务，因为他没有交给spring托管。想开启事务要自己编码。
另外线程之间也是没有影响的，一个线程异常结束，不会影响其他线程，仔细想想道理都知道，还是做实验区印证了下。再重复下， 只有spring托管的bean才会去管理事务，自己new出来的不管理事务，相信自己学的，重要的说三遍，标红吧。


黑色的爆牛团
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
子线程任务发生异常，主线程事务如何回滚
03-10
子线程任务发生异常，主线程事务如何回滚
多线程下 @Async 注解导致 Spring 中的事务失效，该怎么办？？？
Java笔记虾
05-16 6074
点击关注公众号，利用碎片时间学习本文主要解决：Spring @Async 注解多线程导致Spring的注解@Transactional失效问题！问题：多线程为什么会导致事务注解@Transactional失效实现AOP的方法有动态代理、编译期，类加载期织入等等，Spring实现AOP的方法则就是利用了动态代理机制，正因如此，才会导致某些情况下@Async和@Transac...
多线程事务回滚方法
mry6的博客
06-04 2136
1.最近有一个大数据量插入的操作入库的业务场景，需要先做一些其他修改操作，然后在执行插入操作，由于插入数据可能会很多，用到多线程去拆分数据并行处理来提高响应时间，如果有一个线程执行失败，则全部回滚。2.在spring中可以使用@Transactional注解去控制事务，使出现异常时会进行回滚，在多线程中，这个注解则不会生效，如果主线程需要先执行一些修改数据库的操作，当子线程在进行处理出现异常时，主线程修改的数据则不会回滚，导致数据错误。
多线程事务回滚
最新发布
qq_33847026的博客
02-23 446
CountDownLatch 是多线程控制的一种工具，这个工具经常用来用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。
多线程实现事务回滚
热门推荐
吃素的哈士奇de博客
06-10 1万+
多线程实现事务回滚特别说明CountDownLatchCountDownLatch的用法CountDownLatch(num) 简单说明主线程：mainThreadLatch.await() 和mainThreadLatch.countDown()子线程：rollBackLatch.await() 和rollBackLatch.countDown()**为什么所有的子线程会在一瞬间就被所有都释放了？**事务的回滚是怎么结合进去的？假设总共20个子线程，那么其中一个线程报错了怎么实现所有线程回滚。引入变量At
多线程事务怎么回滚？
wcj_java的专栏
01-10 1618
多线程事务处理
java多线程事务处理
m0_49804107的博客
03-28 5456
多线程事务
MySQL事务与锁机制详解
12-14
在InnoDB里面，是通过undo log来实现的，它记录了数据修改之前的值（逻辑日志），一旦发生异常，就可以用undo log来实现回滚操作。 一致性（Consistency）:事务执行的前后数据的完整性保持一致。 隔离性（Isolation...
跟我学习javascript解决异步编程异常方案
01-21
JavaScript的异步调用基于回调函数，当多个异步事务多级依赖时，回调函数会形成多级的嵌套，代码变成 金字塔型结构。这不仅使得代码变难看难懂，更使得调试、重构的过程充满风险。 2、异常处理 回调嵌套不仅仅是使...
202303-Java异常面试题（2023最新版）思维导图.zip
06-16
- 多线程编程 2. 数据库： - 熟悉SQL语言 - 了解关系型数据库和非关系型数据库 - 数据库连接池 - 数据库事务 3. Spring框架： - Spring Boot - Spring MVC - Spring Data - Spring Security - Spring...
C#在后台运行操作BackgroundWorker的用法
08-04
在我们的程序中，经常会有一些耗时较长的运算，为了保证用户体验，不引起界面不响应，我们一般会采用多线程操作，让耗时操作在后台完成，完成后再进行处理或给出提示，在运行中，也会时时去刷新界面上的进度条等显示...
Java 多线程如何做到事务控制
竹林幽深
08-29 1746
公司业务中遇到一个需求，需要同时修改最多约5万条数据，而且还不支持批量或异步修改操作。于是只能写个for循环操作，但操作耗时太长，只能一步一步寻找其他解决方案。对于大批量数据库操作，使用手动事务提交可以很多程度上提高操作效率多线程对数据库进行操作时，并非线程数越多操作时间越快，按上述示例大约在2-5个线程时操作时间最快。对于多线程阻塞事务提交时，线程数量不能过多。来源 | https://blog.csdn.net/qq273766764/article/details/119972911。
SpringBoot 多线程事务回滚，一个注解轻松搞定~
weixin_45738731的博客
06-26 2239
本文是使用了两个注解共同作用实现的，主线程当做协调者，各子线程作为参与者/*** 多线程事务注解: 主事务*///子线程数量/*** 多线程事务注解: 子事务*/两个注解都是用在方法上的，须配合一起使用@MainTransaction注解用在调用方，其参数为必填，参数值为本方法中调用的方法开启的线程数，如：在这个方法中调用的方法中有2个方法用@Async注解开启了子线程，则参数为，另外如果未使用注解，则直接已无多线程事务执行(不影响方法的单线程事务)
多线程如何实现事务回滚？一招帮你搞定！
m0_73311735的博客
04-24 576
特别说明CountDownLatch，变量AtomicBoolean 也是可以直接使用。
JAVA面试题分享三十：多线程事物回滚？
之乎者也·的博客
11-24 725
3、主线程检查子线程执行插入数据库的结果，若有非预期结果出现，主线程标记状态告知子线程回滚，然后使用mainLatch.countDown();将程序控制权再次交给子线程，子线程检测回滚标志，判断是否回滚。日常项目中，经常会出现一个场景，同时批量插入数据库数据，由于逻辑复杂或者其它原因，我们无法使用sql进行批量插入。串行效率低，耗时长，为了提高效率，这个时候我们首先想到多线程并发插入，但是如何控制事务呢。当其中一条线程出现异常，或者处理结果为非预期结果，则全部线程均回滚。开启多条子线程，并发插入数据库。
多线程事物回滚
轻描淡写
01-09 885
在spring中 **@Transactional** 注解可以控制事务，使出现异常时会进行回滚。但在**多线程**中则不生效。例如现在需要插入大量业务数据，但在插入数据之前**主线程先执行删除动作**，之后再将数据**等分分批交由子线程去执行**。那么当其中某个子线程执行失败时，主线程删除的数据则不会回滚，从而导致数据一致性受损。因此需要一个解决方案，如下：
Java 多线程怎么做事务控制
wgq2020的博客
07-21 6831
Java 多线程怎么做事务控制
spring多线程事务失效
06-10
在Spring中，多线程事务失效的原因可能有以下几种： ...4. 避免在多线程事务中出现异常，如果出现异常，就要及时处理异常，以避免整个事务回滚。如果必须回滚，也需要确保所有线程都能够正确回滚。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值