Java技术专题「技术盲区」看实战出发看看线程以及线程池的异常处理机制都有哪些?

Posted 洛神灬殇

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java技术专题「技术盲区」看实战出发看看线程以及线程池的异常处理机制都有哪些?相关的知识,希望对你有一定的参考价值。

线程异常捕获问题

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);
    

子线程在抛出运行时异常,调用自定义的异常处理器,进行异常处理(日志打印)

原理分析

  1. 当一个线程因未捕获的异常而即将终止时,JAVA虚拟机将使用Thread.getUncaughtExceptionHandler()查询该线程以获得其UncaughtExceptionHandler

  2. 调用该handler的uncaughtException()方法,将线程和异常作为参数传递。

  3. 如果没有,则搜索该线程的ThreadGroup的异常处理器。

  4. ThreadGroup中的默认异常处理器实现是将处理工作逐层委托给上层的ThreadGroup,直到某个ThreadGroup的异常处理器能够处理该异常,否则一直传递到顶层的ThreadGroup。

  5. 顶层ThreadGroup的异常处理器委托给默认的系统处理器(如果默认的处理器存在,默认情况下为空),否则把栈信息输出到System.err

线程池的异常捕获方式?

下面给线程池对于不可捕捉异常也提供了多种方式去处理:
  1. run方法里面try/catch所有处理逻辑
public void run() 
   try 
    //处理逻辑
    catch(Exeception e) 
      //打印日志
    

这是一种简单而且不易出错的线程池异常处理方式,推荐使用。

  1. 重写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)方法,该方法的方法体是空,里面没有任何逻辑。

  1. 使用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);
    

以上是关于Java技术专题「技术盲区」看实战出发看看线程以及线程池的异常处理机制都有哪些?的主要内容,如果未能解决你的问题,请参考以下文章

Java技术指南「技术盲区」看看线程以及线程池的异常处理机制都有哪些?

Java技术专题「Java8技术盲区」让我们来看看新一代IO流的开发指引(流升级功能体系)

Java技术专题「Java8技术盲区」函数接口字典-看看还有哪些你所不知道函数接口

#私藏项目实操分享# Java实战系列「技术盲区」Double与Float的坑与解决办法以及BigDecimal的取而代之!

Java技术指南「实战盲区」深入透析Java8的Stream的原理及实战指南

JVM技术专题内存问题分析和故障排查规划指南「实战篇」