【线程池】线程池抛出异常和打印栈帧信息

【一】模拟线程池抛异常

（1）模拟案例

在实际开发中，我们常常会用到线程池，但任务一旦提交到线程池之后，如果发生异常之后，怎么处理？ 怎么获取到异常信息？我们知道了线程池的提交方式：submit和execute的区别，接下来分别使用他们执行带有异常的任务！看结果是怎么样的！

先用伪代码模拟一下线程池抛异常的场景：

public class ThreadPoolException {
    public static void main(String[] args) {
        //创建一个线程池
        ExecutorService executorService= Executors.newFixedThreadPool(1);
        //当线程池抛出异常后 submit无提示，其他线程继续执行
        executorService.submit(new task());
        //当线程池抛出异常后 execute抛出异常，其他线程继续执行新任务
        executorService.execute(new task());
    }
}

//任务类
class task implements  Runnable{
    @Override
    public void run() {
        System.out.println("进入了task方法！！！");
        int i=1/0;
    }
}

（2）运行结果

可以看到：submit不打印异常信息，而execute则会打印异常信息！submit的方式不打印异常信息，显然在生产中，是不可行的，因为我们无法保证线程中的任务永不异常，而如果使用submit的方式出现了异常，直接如上写法，我们将无法获取到异常信息，做出对应的判断和处理，所以下一步需要知道如何获取线程池抛出的异常！

（3）submit()如何获取异常信息

submit()想要获取异常信息就必须使用get()方法！！

//当线程池抛出异常后 submit无提示，其他线程继续执行
Future<?> submit = executorService.submit(new task());
submit.get();

【二】如何获取和处理异常

（1）方案一：使用 try -catch

public class ThreadPoolException {
    public static void main(String[] args) {
        //创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        //当线程池抛出异常后 submit无提示，其他线程继续执行
        executorService.submit(new task());
        //当线程池抛出异常后 execute抛出异常，其他线程继续执行新任务
        executorService.execute(new task());
    }
}
// 任务类
class task implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("进入了task方法！！！");
            int i = 1 / 0;
        } catch (Exception e) {
            System.out.println("使用了try -catch 捕获异常" + e);
        }
    }
}

打印结果：

可以看到 submit 和 execute都清晰易懂的捕获到了异常，可以知道我们的任务出现了问题，而不是消失的无影无踪。

（2）方案二：使用Thread.setDefaultUncaughtExceptionHandler方法捕获异常

方案一中，每一个任务都要加一个try-catch 实在是太麻烦了，而且代码也不好看，那么这样想的话，可以用Thread.setDefaultUncaughtExceptionHandler方法捕获异常

UncaughtExceptionHandler 是Thread类一个内部类，也是一个函数式接口。
内部的uncaughtException是一个处理线程内发生的异常的方法，参数为线程对象t和异常对象e。

应用在线程池中如下所示：重写它的线程工厂方法，在线程工厂创建线程的时候，都赋予UncaughtExceptionHandler处理器对象。

public class ThreadPoolException {
    public static void main(String[] args) throws InterruptedException {


        //1.实现一个自己的线程池工厂
        ThreadFactory factory = (Runnable r) -> {
            //创建一个线程
            Thread t = new Thread(r);
            //给创建的线程设置UncaughtExceptionHandler对象 里面实现异常的默认逻辑
            t.setDefaultUncaughtExceptionHandler((Thread thread1, Throwable e) -> {
                System.out.println("线程工厂设置的exceptionHandler" + e.getMessage());
            });
            return t;
        };

        //2.创建一个自己定义的线程池，使用自己定义的线程工厂
        ExecutorService executorService = new ThreadPoolExecutor(
                1,
                1,
                0,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue(10),
                factory);

        // submit无提示
        executorService.submit(new task());

        Thread.sleep(1000);
        System.out.println("==================为检验打印结果，1秒后执行execute方法");

        // execute 方法被线程工厂factory 的UncaughtExceptionHandler捕捉到异常
        executorService.execute(new task());
    }

}

class task implements Runnable {
    @Override
    public void run() {
        System.out.println("进入了task方法！！！");
        int i = 1 / 0;
    }
}

打印结果如下：

根据打印结果我们看到，execute方法被线程工厂factory中设置的 UncaughtExceptionHandler捕捉到异常，而submit方法却没有任何反应！说明UncaughtExceptionHandler在submit中并没有被调用。这是为什么呢？

在日常使用中，我们知道，execute和submit最大的区别就是execute没有返回值，submit有返回值。submit返回的是一个future ，可以通过这个future取到线程执行的结果或者异常信息。

Future<?> submit = executorService.submit(new task());
//打印异常结果
System.out.println(submit.get()); 

从结果看出：submit并不是丢失了异常，使用future.get（）还是有异常打印的！！那为什么线程工厂factory 的UncaughtExceptionHandler没有打印异常呢？猜测是submit方法内部已经捕获了异常， 只是没有打印出来，也因为异常已经被捕获，因此jvm也就不会去调用Thread的UncaughtExceptionHandler去处理异常。

接下来，验证猜想：

首先看一下submit和execute的源码：
submit源码在底层还是调用的execute方法，只不过多一层Future封装，并返回了这个Future，这也解释了为什么submit会有返回值

//submit()方法
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    
    //execute内部执行这个对象内部的逻辑，然后将结果或者异常 set到这个ftask里面
    RunnableFuture<T> ftask = newTaskFor(task); 
    // 执行execute方法
    execute(ftask); 
    //返回这个ftask
    return ftask;
}

可以看到submit也是调用的execute，在execute方法中，我们的任务被提交到了addWorker(command, true) ，然后为每一个任务创建一个Worker去处理这个线程，这个Worker也是一个线程，执行任务时调用的就是Worker的run方法！run方法内部又调用了runworker方法！如下所示：

    public void run() {
            runWorker(this);
     }
     
	 final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
        	//这里就是线程可以重用的原因，循环+条件判断，不断从队列中取任务       	
        	//还有一个问题就是非核心线程的超时删除是怎么解决的
        	//主要就是getTask方法()见下文③
            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 {
                    	//execute的方式可以重写此方法处理异常
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            //出现异常时completedAbruptly不会被修改为false
            completedAbruptly = false;
        } finally {
        	//如果如果completedAbruptly值为true，则出现异常，则添加新的Worker处理后边的线程
            processWorkerExit(w, completedAbruptly);
        }
    }

核心就在 task.run(); 这个方法里面了， 期间如果发生异常会被抛出。

（1）如果用execute提交的任务，会被封装成了一个runable任务，然后进去 再被封装成一个worker,最后在worker的run方法里面调用runWoker方法， runWoker方法里面执行任务任务，如果任务出现异常，用try-catch捕获异常往外面抛，我们在最外层使用try-catch捕获到了 runWoker方法中抛出的异常。因此我们在execute中看到了我们的任务的异常信息。
（2）那么为什么submit没有异常信息呢？ 因为submit是将任务封装成了一个futureTask ，
然后这个futureTask被封装成worker，在woker的run方法里面，最终调用的是futureTask的run方法， 猜测里面是直接吞掉了异常，并没有抛出异常，因此在worker的runWorker方法里面无法捕获到异常。

下面来看一下futureTask的run方法，果不其然，在try-catch中吞掉了异常，将异常放到了 setException(ex);里面

   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);
            }
           	//省略下文
			。。。。。。

setException(ex)方法如下：将异常对象赋予outcome

 protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        	//将异常对象赋予outcome，记住这个outcome，
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

将异常对象赋予outcome有什么用呢？这个outcome是什么呢？当我们使用submit返回Future对象，并使用Future.get()时， 会调用内部的report方法！

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    //注意这个方法
    return report(s);
}

reoport里面实际上返回的是outcome ,刚好之前的异常就set到了这个outcome里面

    private V report(int s) throws ExecutionException {
    	//设置`outcome`
        Object x = outcome;
        if (s == NORMAL)
        	//返回`outcome`
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }

因此，在用submit提交的时候，runable对象被封装成了future ，future 里面的 run方法在处理异常时， try-catch了所有的异常，通过setException(ex);方法设置到了变量outcome里面， 可以通过future.get获取到outcome。

所以在submit提交的时候，里面发生了异常， 是不会有任何抛出信息的。而通过future.get（）可以获取到submit抛出的异常！在submit里面，除了从返回结果里面取到异常之外, 没有其他方法。因此，在不需要返回结果的情况下，最好用execute ，这样就算没有写try-catch，疏漏了异常捕捉，也不至于丢掉异常信息。

（3）方案三：重写afterExecute进行异常处理

通过上述源码分析，在excute的方法里面，可以通过重写afterExecute进行异常处理，但是注意！ 这个也只适用于excute提交(submit的方式比较麻烦，下面说)，因为submit的task.run里面把异常吞了，根本不会跑出来异常，因此也不会有异常进入到afterExecute里面。

在runWorker里面，调用task.run之后，会调用线程池的 afterExecute(task, thrown) 方法

final void runWorker(Worker w) {
//当前线程
        Thread wt = Thread.currentThread();
        //我们的提交的任务
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            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方法 
                        task.run(); //如果是futuretask的run,里面是吞掉了异常，不会有异常抛出，
                       // 因此Throwable thrown = null;  也不会进入到catch里面
                    } 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和异常
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

重写afterExecute处理execute提交的异常

public class ThreadPoolException3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {


        //1.创建一个自己定义的线程池
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue(10)
        ) {
            //重写afterExecute方法
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println("afterExecute里面获取到异常信息，处理异常" + t.getMessage());
            }
        };
        
        //当线程池抛出异常后 execute
        executorService.execute(new task());
    }
}

class task3 implements Runnable {
    @Override
    public void run() {
        System.out.println("进入了task方法！！！");
        int i = 1 / 0;
    }
}

执行结果：我们可以在afterExecute方法内部对异常进行处理
如果要用这个afterExecute处理submit提交的异常， 要额外处理。判断Throwable是否是FutureTask，如果是代表是submit提交的异常，代码如下：

public class ThreadPoolException3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {


        //1.创建一个自己定义的线程池
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue(10)
        ) {
            //重写afterExecute方法
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                //这个是excute提交的时候
                if (t != null) {
                    System.out.println("afterExecute里面获取到excute提交的异常信息，处理异常" + t.getMessage());
                }
                //如果r的实际类型是FutureTask 那么是submit提交的，所以可以在里面get到异常
                if (r instanceof FutureTask) {
                    try {
                        Future<?> future = (Future<?>) r;
                        //get获取异常
                        future.get();

                    } catch (Exception e) {
                        System.out.println("afterExecute里面获取到submit提交的异常信息，处理异常" + e);
                    }
                }
            }
        };
        //当线程池抛出异常后 execute
        executorService.execute(new task());
        
        //当线程池抛出异常后 submit
        executorService.submit(new task());
    }
}

class task3 implements Runnable {
    @Override
    public void run() {
        System.out.println("进入了task方法！！！");
        int i = 1 / 0;
    }
}

处理结果如下：
可以看到使用重写afterExecute这种方式，既可以处理execute抛出的异常，也可以处理submit抛出的异常

【三】线程池处理异常的逻辑分析

线程池中实际运行的是线程池自身的线程，只是在runWorker方法中调用了我们传递进入Runnable对象的run()方法，那么如果run()方法中出现异常了，那么要怎么处理？会不会将我们的线程池停掉？

我们先来看下runWorker()方法的具体逻辑：

final void runWorker(Worker w) {
  Thread wt = Thread.currentThread();
  Runnable task = w.firstTask;
  w.firstTask = null;
  w.unlock(); // allow interrupts
  boolean completedAbruptly = true;
  try {
    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();
      }
    }
    completedAbruptly = false;
  } finally {
    processWorkerExit(w, completedAbruptly);
  }
}

在代码中我们看到，在调用用户Runnable实例方法run()的时候，进行了try…catch…finally，但是在catch()中是直接将异常抛出了，也就是说并未在while循环内消化掉，而是抛出给外层，这时会将while循环终止掉，然后在外层的try…finally中并未捕获内部传出的异常，所以异常信息会继续往上抛出，我们来关注一下这两层try的finally代码块，内部的finally中执行了一个空的方法afterExecute()，这个方法是留给我们自定义线程池时使用的，和beforeExecute()方法一样，既然是空方法，那我们就先不用去看它了，来看下外层的finally代码块

private void processWorkerExit(Worker w, boolean completedAbruptly) {
  // 从runWorker方法中传过来的是true，所以这句目前版本中必定会被执行到
  // 作用是将当前线程池中的有效线程数-1，意思也就是出现异常的线程会被从线程池中拿掉
  // 为什么说是出现异常的线程会被拿掉呢？因为在try内部是一个while循环，除非关闭核心线程或运行中线程出现异常，否则不会执行到这里
  if (completedAbruptly)
    decrementWorkerCount();
 
  final ReentrantLock mainLock = this.mainLock;
  mainLock.lock();
  try {
    // 更新完成的任务数，只要是被线程池线程执行过的，不管是否出现异常，都被认为是执行成功的任务
    completedTaskCount += w.completedTasks;
    // 将当前Worker线程从线程池中移除销毁
    workers.remove(w);
  } finally {
    mainLock.unlock();
  }
 
  tryTerminate();
 
  // 一系列判断，主要是判断是否符合给线程池创建新的线程
  int c = ctl.get();
  if (runStateLessThan(c, STOP)) {
    if (!completedAbruptly) {
      int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
      if (min == 0 && ! workQueue.isEmpty())
        min = 1;
      if (workerCountOf(c) >= min)
        return;
    }
    // 给线程池创建新的线程，core之所以传递false，是因为这里要防止创建失败
    addWorker(null, false);
  }
}

通过源码我们看到在处理任务的过程中，如果线程出现异常，则会将该线程从线程池中移除销毁，然后再新创建一个线程加入到线程池中，也就是说在任务发生异常的时候，会终结掉运行它的线程。

【四】发生异常后，打印栈帧信息的三种方式

在Java编程中，获取堆栈信息对于调试和故障排除非常重要。Java提供了多种方式来获取当前线程的堆栈信息，以便了解线程执行的情况。下面介绍几种常用的方法：

（1）使用Thread.currentThread().getStackTrace()

可以通过Thread类的currentThread()方法和getStackTrace()方法来获取当前线程的堆栈信息，示例代码如下：

StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
for (StackTraceElement element : stackTraceElements) {
    System.out.println(element.getClassName() + " -> " + element.getMethodName() + " : " + element.getLineNumber());
}

这段代码将打印当前线程的堆栈信息，包括类名、方法名和行号。

（2）使用Throwable对象的getStackTrace()

还可以通过创建一个Throwable对象，并调用其getStackTrace()方法来获取堆栈信息，示例代码如下：

Throwable t = new Throwable();
StackTraceElement[] stackTraceElements = t.getStackTrace();
for (StackTraceElement element : stackTraceElements) {
    System.out.println(element.getClassName() + " -> " + element.getMethodName() + " : " + element.getLineNumber());
}

这种方式同样可以获取当前线程的堆栈信息，并输出类名、方法名和行号。

（3）使用ThreadMXBean

ThreadMXBean是Java Management Extensions (JMX) 中用于管理线程的接口，可以通过它来获取线程的详细信息，包括堆栈信息。示例代码如下：

ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(true, true);
for (ThreadInfo info : threadInfos) {
    System.out.println(info.getThreadName());
    StackTraceElement[] stackTraceElements = info.getStackTrace();
    for (StackTraceElement element : stackTraceElements) {
        System.out.println("\t" + element.getClassName() + " -> " + element.getMethodName() + " : " + element.getLineNumber());
    }
}

通过ThreadMXBean可以获取所有线程的堆栈信息，并且输出更加详细的线程信息。

在实际开发中，获取堆栈信息通常用于记录错误日志、调试程序或监控线程执行情况。下面以记录错误日志为例，演示如何获取堆栈信息并结合实际应用场景：

javaCopy code
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
public class StackTraceExample {
    public static void main(String[] args) {
        try {
            // 模拟一个空指针异常
            String str = null;
            str.length();
        } catch (Exception e) {
            // 在错误日志中记录堆栈信息
            logStackTrace(e);
        }
    }
    public static void logStackTrace(Exception e) {
        try (FileWriter fileWriter = new FileWriter("error.log");
             PrintWriter printWriter = new PrintWriter(fileWriter)) {
            printWriter.println("发生异常：" + e.toString());
            printWriter.println("堆栈信息：");
            for (StackTraceElement element : e.getStackTrace()) {
                printWriter.println(element.getClassName() + " -> " + element.getMethodName() + " : " + element.getLineNumber());
            }
            System.out.println("堆栈信息已记录到error.log文件中");
        } catch (IOException ex) {
            System.err.println("记录堆栈信息发生错误：" + ex.getMessage());
        }
    }
}

在上述示例中，我们模拟了一个空指针异常，并在logStackTrace()方法中捕获异常并记录堆栈信息到error.log文件中。通过调用e.getStackTrace()方法获取异常的堆栈信息，并逐行写入日志文件中，方便后续分析排错。 运行该示例代码后，如果发生空指针异常，将会在项目目录下生成一个error.log文件，记录异常信息和堆栈跟踪信息。 这样结合实际应用场景，我们可以更好地利用堆栈信息来帮助定位和解决程序中的问题，提高程序的健壮性和可维护性。

Thread.currentThread() 是一个静态方法，它可以返回当前正在执行的线程对象。在多线程编程中，每个线程都有自己的堆栈空间和执行流，Thread.currentThread() 方法可以让程序获取当前代码正在哪个线程中执行的信息。 具体来说，Thread.currentThread() 返回一个表示当前线程的 Thread 对象。通过这个对象，可以获取当前线程的一些属性，比如线程名称、线程优先级、线程状态等。另外，也可以通过当前线程对象来操作线程，比如暂停线程、恢复线程、中断线程等。 在多线程环境下，如果有多个线程同时在执行，不同线程调用 Thread.currentThread() 将会返回不同的 Thread 对象，因为每个线程都有自己的执行上下文。 下面是一个简单的示例代码，演示了如何使用 Thread.currentThread() 方法获取当前线程的名称并进行输出：

javaCopy code
public class CurrentThreadExample {
    public static void main(String[] args) {
        Thread currentThread = Thread.currentThread();
        String threadName = currentThread.getName();
        System.out.println("当前线程的名称是：" + threadName);
    }
}

在上面的示例中，Thread.currentThread() 方法返回当前线程对象，然后调用 getName() 方法获取当前线程的名称，最后输出当前线程的名称。这样就可以通过 Thread.currentThread() 方法方便地获取当前线程对象，以便对当前线程进行操作或获取相关信息。