标签：task Java Thread 盲区 线程 new 异常 public
线程异常捕获问题
Java 异常在线程之间不是共享的，在线程中抛出的异常是线程自己的异常，主线程并不能捕获到。也就是说你把线程执行的代码看成另一个主函数。
上面 A 和 B 的运行是互相独立的，虽然说你看到 B 所在代码块的函数内容在 main 中，但是 main 并不能捕获到这个 Runnable 里函数的异常，因为它不在同一个线程之中运行，B 中抛出的异常如果你不在另一个线程捕获的话，相当于就是没有异常处理，无法捕获。
在 java 多线程程序中，所有线程都不允许抛出未捕获的 checked exception，也就是说各个线程需要自己将 checked exception 处理掉，run 方法上面进行了约束，不可以抛出异常(throws Exception)
public class ThreadSample implements Runnable {
@Override
public void run() { //run()方法上不可以抛出异常
System.out.println("任务开始执行");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int i = 10 /0; //这里抛出RuntimeException()
System.out.println("任务执行结束");
}
}
public class ThreadErrorTest {
public static void main(String[] args) {
Thread a = new Thread(new ThreadSample());
a.start();
System.out.println("主线程执行结束！！！");
}
}
-
a 线程运行抛出异常不会影响主线程的执行，当此类异常产生时，子线程就会终结。
-
所以，无法在主线程中捕获子线程抛出的异常进行处理，只能在 run 方法内部对业务逻辑进行 try/catch。
-
线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而无法委托到外部。
对于线程的设置异常捕捉器
Thread 中 Java 提供了一个 setUncaughtExceptionHandler 的方法来设置线程的异常处理函数，你可以把异常处理函数传进去，当发生线程的未捕获异常的时候，由 JVM 来回调执行。
如何在获取子线程内部的线程错误执行结果呢？
-
可以使用 Thread.UncaughtExceptionHandler 为每个线程设置异常处理器，Thread.UncaughtExceptionHandler.uncaughtException()方法会在线程因未捕获的异常而面临死亡时被调用，上述子线程本身因为异常终止打印到控制台也是由于 UncaughtExceptionHandler
-
实现 UncaughtExceptionHandler 接口并重写 uncaughtException 方法，在 uncaughtException 方法中打印日志即可：
public class ThreadErrorTest {
public static void main(String[] args) {
Thread a = new Thread(new ThreadSample());
a.setUncaughtExceptionHandler(new RuntimeExceptionHandle());
a.start();
System.out.println("主线程执行结束！！！");
}
}
public class RuntimeExceptionHandle implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread t, Throwable e) {
//打印异常信息到日志
System.out.println("异常处理器调用, 打印日志: " + e);
}
}
子线程在抛出运行时异常，调用自定义的异常处理器，进行异常处理（日志打印）
原理分析
-
当一个线程因未捕获的异常而即将终止时，JAVA 虚拟机将使用 Thread.getUncaughtExceptionHandler()查询该线程以获得其 UncaughtExceptionHandler
-
调用该 handler 的 uncaughtException()方法，将线程和异常作为参数传递。
-
如果没有，则搜索该线程的 ThreadGroup 的异常处理器。
-
ThreadGroup 中的默认异常处理器实现是将处理工作逐层委托给上层的 ThreadGroup，直到某个 ThreadGroup 的异常处理器能够处理该异常，否则一直传递到顶层的 ThreadGroup。
-
顶层 ThreadGroup 的异常处理器委托给默认的系统处理器（如果默认的处理器存在，默认情况下为空），否则把栈信息输出到 System.err
线程池的异常捕获方式？
下面给线程池对于不可捕捉异常也提供了多种方式去处理:
-
run 方法里面 try/catch 所有处理逻辑
public void run() {
try {
//处理逻辑
} catch(Exeception e) {
//打印日志
}
}
这是一种简单而且不易出错的线程池异常处理方式，推荐使用。
-
重写 ThreadPoolExecutor.afterExecute 方法
线程池的线程在执行结束前肯定调用 afterExecute 方法，所有只需要重写该方法即可。
public class MyThreadPool extends ThreadPoolExecutor {
public MyThreadPool(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
@Override
public void afterExecute(Runnable r, Throwable t) {
if(t != null) {
System.out.println("打印异常日志：" + t);
}
}
}
-
分析线程池源码：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
/**
* addWorker方法部分内容
*/
w = new Worker(firstTask); //封装成Worker对象
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
/**
* worker对象里面的run方法部分内容
*/
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown); //执行改方法
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
-
首先 ThreadPoolExecutor 中 execute 方法会将传入的 task 封装成 Worker 对象，在进入 Worker 对象的 run 方法，发现异常被线程池捕获了。
-
但是最后在 finally 会执行 afterExecute(task, thrown)方法，该方法的方法体是空，里面没有任何逻辑。
-
使用 submit 执行任务
我们知道在使用 submit 执行任务，该方法将返回一个 Future 对象，不仅仅是任务的执行结果，异常也会被封装到 Future 对象中，通过 get()方法获取。
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask); //封装成FutureTask对象交给execute方法
return ftask;
}
由于调用 ThreadPoolExecutor 的 execute 方法，会被封装成 Worker 对象，然后调用 FutureTask 对象的 run 方法：
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex); //捕获异常
}
if (ran)
set(result);
}
} finally{ ...... }
捕获异常后调用 setException(ex)方法，setExcetion 首先是将一个异常信息赋值给一个全局变量 outcome，并且将全局的任务状态 state 字段通过 CAS 更新为 3(异常状态)然后最后做一些清理工作。
FutureTask.get()方法中，会对 setException 方法中设置的 outcome 和 state 做一些逻辑判断，然后直接往上抛出了异常，所以我们就可以在主线程中捕获这个异常。
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
private V report(int s) throws ExecutionException {
Object x = outcome;
if (s == NORMAL)
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}
自定义异常处理器
由于线程池传入的参数是 Runnable 不是 Thread，执行一个个对应的任务，所以这里我们需要使用 ThreadFactory 创建线程池
public class MyThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler(new RuntimeExceptionHandle());
return t;
}
}
继承 ThreadFactory，并重写 newThread(Runnable r)方法设置异常处理器,在异常处理器中捕获并处理异常（打印日志）
public class ThreadPoolExecption1 {
private static ExecutorService executor = Executors.newSingleThreadExecutor(new MyThreadFactory());
public static void main(String[] args) {
Task task = new Task();
executor.execute(task);
executor.submit(task);
}
}
这种方法比较麻烦，更简单的是在 Thread 类中设置一个静态域，并将这个处理器设置为默认异常处理器，但是，这个属于全局化的，慎用！如果需要定制化，还需要专门定制。
public class ThreadPoolException2 {
private static ExecutorService executor = Executors.newFixedThreadPool(3);
public static void main(String[] args) {
Thread.setDefaultUncaughtExceptionHandler(new RuntimeExceptionHandle());
Task task = new Task();
executor.execute(task);
//executor.submit(task);
}
}
标签：task,Java,Thread,盲区,线程,new,异常,public 来源： https://blog.csdn.net/m0_60720471/article/details/120795470
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。