多线程异常 和 事务(一)

最新推荐文章于 2024-03-11 17:07:28 发布
最新推荐文章于 2024-03-11 17:07:28 发布
阅读量7k 收藏 4
点赞数 2
分类专栏： spring java多线程 文章标签： java 多线程 异常 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WeiJiaXiaoBao/article/details/51217265
版权

1，首先提出几个问题：


1.1，子线程中的异常在主线程中是否可以catch

1.2，在spring中主线程有事务，那么子线程中有事务码


2，先看第一个问题


2.1，我们在main方法里面测试，代码如下

package com.pingan.test.call;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class MutiThreadException {

	
	public static void main(String[] args) {
		System.out.println("MutiThreadException.main()------>start<------");
		try {
			List<Future<Object>> resultList = new ArrayList<Future<Object>>();  
//			ExceptionHandle exceptionHandle = new ExceptionHandle();
			ExecutorService service=Executors.newFixedThreadPool(6);
			for (int i = 0; i < 3; i++) {
				Thread t=new Thread(new  Runnable() {
					@Override
					public void run() {
						System.out.println("id "+Thread.currentThread().getName()+"---start>");
						if(Thread.currentThread().getName().endsWith("2")){
//							int i=1/0;
							  throw new RuntimeException();  
						}
						try {
							Thread.sleep(2000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println("id "+Thread.currentThread().getName()+"----end:");
					}
				});
//				t.setUncaughtExceptionHandler(new ExceptionHandle());
				t.start();
//				Future<Object> future = (Future<Object>) service.submit(t);
//				resultList.add(future);
			}
//			for(Future f:resultList){
//				Object o=f.get();
//				System.out.println(o);
//			}
//			service.shutdown();
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("MutiThreadException.main()------>end<------");
	}
}

run后的结果如下

MutiThreadException.main()------>start<------
id Thread-0---start>
id Thread-1---start>
MutiThreadException.main()------>end<------
id Thread-2---start>
Exception in thread "Thread-2" java.lang.RuntimeException
	at com.pingan.test.call.MutiThreadException$1.run(MutiThreadException.java:26)
	at java.lang.Thread.run(Thread.java:662)
id Thread-0----end:
id Thread-1----end:
可以看出日志打印了异常，是否就说明我们catch到了异常呢，答案：否。我们可以吧catch中的 e.printStackTrace()注释，然后再次运行，会发现结果依然一样。
什么原因呢，其实是异常在子线程中逃逸到了控制台，并没有被主线程catch到。thread的run方法不允许抛出异常，所以我们要在线程里自己处理，对于运行时异常如果没有catch那么就逃逸到控制台。
当然API也提供了一个接口UncaughtExceptionHandler，我们实现就可以然后在set到线程中，代码如下 
package com.pingan.test.call;

import java.lang.Thread.UncaughtExceptionHandler;

public class ExceptionHandle implements UncaughtExceptionHandler{

	@Override
	public void uncaughtException(Thread t, Throwable e) {
		System.out.println("ExceptionHandle.uncaughtException()");
	}

	
}

2.2，我们把测试代码中的这一行注释掉t.setUncaughtExceptionHandler(new ExceptionHandle());
run后的结果如下：

MutiThreadException.main()------>start<------
id Thread-0---start>
id Thread-1---start>
MutiThreadException.main()------>end<------
id Thread-2---start>
ExceptionHandle.uncaughtException()
id Thread-1----end:
id Thread-0----end:

可以看到异常被内部捕获处理掉，但是id Thread-2---end没有打印，说明线程异常后直接结束了，没有走下面的代码。所以我觉得这个接口没有实际的应用场景。

2.3，如果要是用线程池呢

我们注释掉这两行

t.setUncaughtExceptionHandler(new ExceptionHandle());

t.start();

这两行放开注释 

Future<Object> future = (Future<Object>) service.submit(t);

service.shutdown();

Run代码运行如下

MutiThreadException.main()------>start<------
MutiThreadException.main()------>end<------
id pool-1-thread-1---start>
id pool-1-thread-2---start>
id pool-1-thread-3---start>
id pool-1-thread-1----end:
id pool-1-thread-3----end:

可以看到控制台没有异常，说明ExecutorService已经处理过了，那我们怎么知道子线程是否有异常呢，代码中我们看到submit是有返回值的，修改测试代码如下

package com.pingan.test.call;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class MutiThreadException {

	
	public static void main(String[] args) {
		System.out.println("MutiThreadException.main()------>start<------");
		ExecutorService service=null;
		try {
			List<Future<Object>> resultList = new ArrayList<Future<Object>>();  
//			ExceptionHandle exceptionHandle = new ExceptionHandle();
			service=Executors.newFixedThreadPool(6);
			for (int i = 0; i < 3; i++) {
				Thread t=new Thread(new  Runnable() {
					@Override
					public void run() {
						System.out.println("id "+Thread.currentThread().getName()+"---start>");

						if(Thread.currentThread().getName().endsWith("1")){
							try {
								Thread.sleep(2000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							int i=1/0;
//							  throw new RuntimeException();  
						}
						if(Thread.currentThread().getName().endsWith("2")){
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
//							int i=1/0;
							  throw new RuntimeException();  
						}
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println("id "+Thread.currentThread().getName()+"----end:");
					}
				});
//				t.setUncaughtExceptionHandler(new ExceptionHandle());
//				t.start();
				Future<Object> future = (Future<Object>) service.submit(t);
				resultList.add(future);
			}
			System.out.println("resultList.size:"+resultList.size());
			for(Future<Object> f:resultList){
				System.out.println("f------>"+f);
				Object o=null;
//				try {
					o=f.get();
//				} catch (ExecutionException  e) {
//					e.printStackTrace();
//				}
//				System.out.println(o);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			service.shutdown();
		}
		System.out.println("MutiThreadException.main()------>end<------");
	}
}


Run运行结果如下

MutiThreadException.main()------>start<------
id pool-1-thread-1---start>
id pool-1-thread-2---start>
resultList.size:3
id pool-1-thread-3---start>
f------>java.util.concurrent.FutureTask@7d67d940
id pool-1-thread-3----end:
java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)
	at java.util.concurrent.FutureTask.get(FutureTask.java:83)
	at com.pingan.test.call.MutiThreadException.main(MutiThreadException.java:63)
Caused by: java.lang.ArithmeticException: / by zero
	at com.pingan.test.call.MutiThreadException$1.run(MutiThreadException.java:33)
	at java.lang.Thread.run(Thread.java:662)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:439)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
	at java.util.concurrent.FutureTask.run(FutureTask.java:138)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
	at java.lang.Thread.run(Thread.java:662)
MutiThreadException.main()------>end<------

这个里面信息还是比较多的，可以看到线程1和2都没有结束，打印的异常是线程1抛出的异常，线程1一共休眠了3秒，线程2休眠了2秒，为什么线程1的异常打印了而没有打印1的异常呢？为什么？为什么呢？
这里要怪我烦的错误，我们是吧Futrue放到List里面然后遍历获取的，肯定是按顺序获取线程1,2,3的结果的，当获取1的时候f.get方法就抛了异常了，方法直接就结束了。所以我们修改代码吧f.get()方法try/catch住，捕获ExecutionException捕获执行异常，再次运行

MutiThreadException.main()------>start<------
id pool-1-thread-1---start>
id pool-1-thread-2---start>
resultList.size:3
id pool-1-thread-3---start>
f------>java.util.concurrent.FutureTask@2ce83912
id pool-1-thread-3----end:
java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
	at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)
	at java.util.concurrent.FutureTask.get(FutureTask.java:83)
	at com.pingan.test.call.MutiThreadException.main(MutiThreadException.java:63)
Caused by: java.lang.ArithmeticException: / by zero
	at com.pingan.test.call.MutiThreadException$1.run(MutiThreadException.java:33)
	at java.lang.Thread.run(Thread.java:662)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:439)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)null
f------>java.util.concurrent.FutureTask@4318f375

	at java.util.concurrent.FutureTask.run(FutureTask.java:138)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
	at java.lang.Thread.run(Thread.java:662)
java.util.concurrent.ExecutionException: java.lang.RuntimeException
	at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)
	at java.util.concurrent.FutureTask.get(FutureTask.java:83)
	at com.pingan.test.call.MutiThreadException.main(MutiThreadException.java:63)
Caused by: java.lang.RuntimeException
	at com.pingan.test.call.MutiThreadException$1.run(MutiThreadException.java:43)
	at java.lang.Thread.run(Thread.java:662)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:439)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
	at java.util.concurrent.FutureTask.run(FutureTask.java:138)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
	at java.lang.Thread.run(Thread.java:662)
null
f------>java.util.concurrent.FutureTask@1b17a8bd
null
MutiThreadException.main()------>end<------

这次看到两个异常都捕获到了我们在主线程拿到了子线程抛出的异常。上面犯错要反省一下，什么原因导致我烦的错误呢，就是我在最外面用EXCEPTION捕获的所有异常，所以eclipse没有提示f.get（）方法的异常。我们应该在for循环的里面捕获异常，让循环走下去。日志还有一个信息那就是返回值我们看到是null，因为thread的run方法确实没有返回值。


感觉文章有点长了，下面文章接着继续，我们在spring中看下关于事务的问题





黑色的爆牛团
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
子线程任务发生异常，主线程事务如何回滚
03-10
子线程任务发生异常，主线程事务如何回滚
多线程事务
weixin_37895026的博客
03-31 1749
1，最近有一个大数据量插入的操作入库的业务场景，需要先做一些其他修改操作，然后在执行插入操作，由于插入数据可能会很多，用到多线程去拆分数据并行处理来提高响应时间，如果有一个线程执行失败，则全部回滚。注解去控制事务，使出现异常时会进行回滚，在多线程中，这个注解则不会生效，如果主线程需要先执行一些修改数据库的操作，当子线程在进行处理出现异常时，主线程修改的数据则不会回滚，导致数据错误。可以发现子线程组执行时，有一个线程执行失败，其他线程也会抛出异常，但是主线程中执行的删除操作，没有回滚，测试结果：抛出异常，
解决多线程批量插入中的事物一致性问题
weixin_42324471的博客
05-22 4979
在开发当中我们，我们有时为了加快执行速度，会使用到多线程！尤其在大量数据插入数据库时，我们需要使用多线程进行批量插入，加快程序的执行效率！ 但是由于多线程中每个线程的事物是不一致的导致程序不一致！为了保证多个线程执行插入时，事物的一致性！我们需要将每个线程的事物状态保存到一个集合当中，当其中某个线程抛出异常时，我将所有线程的事物进行回滚！ 实现思路： 1、将所有线程的事物状态保存到一个集合里面，该集合必须是线程安全的！ 2、定义一个集合，当线程发生异常时，往集合里面添加数据！ 3、当异常标志集合中
Spring多线程事务处理方案
最新发布
qq_43503653的博客
03-11 1984
本文介绍了在spring体系下对多线程事务的处理方案
多线程基础
tiaopimao3185的博客
04-24 294
多线程的一些基础     java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺序执行的代码）。java使用线程执行体来代表这段程序流。    一、进程和线程的定义和区别     进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。     线程：...
Java中继承thread类与实现Runnable接口的区别
lqluckywind的专栏
08-14 687
Java中线程的创建有两种方式：   1．  通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中 2．  通过实现Runnable接口，实例化Thread类       在实际应用中，我们经常用到多线程，如车站的售票系统，车站的各个售票口相当于各个线程。当我们做这个系统的时候可能会想到两种方式来实现，继承Thread类或实现Runnable接口，现在看
@Transactional中的几种事务传播和编程式事务
weixin_49390750的博客
08-18 472
@Transactional中的几种事务传播和编程式事务
MySQL事务与锁机制详解
12-14
事务是逻辑上的一组操作，组成这组操作的各个逻辑单元，要么一起成功，要么一起失败。 1.2 哪些引擎支持事务 InnoDB支持事务 1.3 事务的四大特性 原子性（Atomicity）:强调事务的不可分割，也就意味着我们对数据库的...
跟我学习javascript解决异步编程异常方案
01-21
JavaScript的异步调用基于回调函数，当多个异步事务多级依赖时，回调函数会形成多级的嵌套，代码变成 金字塔型结构。这不仅使得代码变难看难懂，更使得调试、重构的过程充满风险。 2、异常处理 回调嵌套不仅仅是使...
202303-Java异常面试题（2023最新版）思维导图.zip
06-16
- 多线程编程 2. 数据库： - 熟悉SQL语言 - 了解关系型数据库和非关系型数据库 - 数据库连接池 - 数据库事务 3. Spring框架： - Spring Boot - Spring MVC - Spring Data - Spring Security - Spring...
leetcode手册JAVA-JavaLearn:学习java的路线和项目实战，javalearner快来看一看吧！
06-30
并发与多线程 并发编程基础 线程池 锁 并发容器 原子类 juc并发工具类 1.2 数据结构与算法 1.2.1 数据结构 字符串 数组 链表 二叉树 堆，栈，队列 哈希 1.2.2 算法 查找 排序 贪心 分治 动态规划 回溯 1.3 计算机...
java线程池方式执行run任务及在线程run方法中注入service
星痕の博客
11-03 3226
背景：接口1内需要调用接口2，接口2功能是执行一个长时间任务，执行完成后才会返回结果（比如执行5min后获取到执行结果），但是接口1内调接口2时不能等待5min后才返回结果，接口1需要返回自己的结果 方式：以线程池方式来执行任务，接口1触发接口2后不等待，直接返回自己的内容或做其他操作，将接口2的任务扔进线程池中任其执行，执行完了后可以接着做其他操作 例子： 2个数据库表：report（存储报告连接）、task（任务表，包含任务执行的状态status和报告id） 1、创建业务接口controller
多线程执行顺序以及run方法的调用
优质后端技术知识记录
01-07 2316
首先抛出问题 在上一篇ThreadLocal使用方法中，我尝试修改了博主的代码 public class Test1 { static class A{ public void get(){ /*取得当前线程所需要的值*/ System.out.println("A"+ti.get()); } ......
JAVA—事务处理三种方式：Thread，Runnable，Callable
飞扬晴雪
04-19 1265
JAVA—事务处理三种方式： 1.Thread 说明：Thread 类中包含run方法，通过改写run方法，然后实例化Thread 类，执行事务。 代码实现 public class Threadnew { public static void main(String[] args) { //1.2匿名实例化类继承MyThread类，并且启动 new MyThread().start(); } } //1.1自定义继承MyThread类继
Java多线程的start()方法和run()方法
clearLB的博客
08-02 543
为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法 new一个Thread，线程进入了新建状态。调用start()方法，线程就进入了就绪态，当分配到时间片后就可以开始运行了，也就是线程进入到了运行态。start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这就是真正的多线程工作，而直接执行run()方法，会把run()方法当作一个main线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作，run方法只是thread的一个普通方
java 两个service一个有事务一个没有_Spring事务方法嵌套引发的异常与问题分析
weixin_39957027的博客
11-23 1608
1 案例背景 由于Spring框架优秀的特性，很多java项目都会集成Spring。其中，Spring的轻量级声明式事务管理极大的简化了开发者对于事务的开发工作。 而我在最近的项目开发过程中，遇到了一个奇怪的事务异常：Transaction rolled back because it has been marked as rollback-only。 这篇案例将会对代...
Spring在多线程环境下如何确保事务一致性
m0_53157173的博客
10-20 9439
如何实现Spring在多线程环境下的事物一致性呢？还不快学起来！！！
@Transactional
热门推荐
走在命运的左岸
01-09 4万+
@Transactional 事务管理的目的 在出现异常的情况下，保证数据的一致性；数据提交操作回滚至异常发生前的状态 事务管理的方式： Spring（Spring Framework 提供对事务管理的抽象接口） 支持两种事务管理方式： 编程式事务管理：使用TransactionTemplate或PlatformTransactionManager实现 声明式事务管理
多线程事务控制工具-RunnableTransactionManager
a1023934860的博客
10-22 776
开发原因 由于，spring的变量都存在线程本地内存中(防止并发冲突)，那么当我们在一个service调用多个线程的时候，就没有办法进行事务的统一控制(回滚)。 为此，赶紧百度找个解决方案，呈现出来。 原理 主要原理就是利用CountDownLatch 的并发控制，使用编程事务，将每个线程进行管理，是的你没有听错，不是事务，是线程。因为我试过定义一个数组将各个线程的状态存起来，但是很现实，父线程无法识别子线程的变量。（在这个时候我想到了另一种方法就是使用父传子线程变量的方式，实现事务的共享，不过还没实现）。
怎么让多线程的事务是同一个
07-08
要确保多线程的事务是同一个，可以采取以下几种方式： ...需要注意的是，在设计和实现多线程事务时，要考虑线程安全性、并发控制和数据一致性等方面的问题，并且合理地处理异常情况，以保证事务的正确执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值