转自： https://www.cnblogs.com/chenfei0801/archive/2013/04/23/3039286.html

在java多线程程序中，所有线程都不允许抛出未捕获的checked exception（比如sleep时的InterruptedException） ，也就是说各个线程需要自己把自己的checked exception处理掉 。这一点是通过java.lang.Runnable.run()方法声明(因为此方法声明上没有throw exception部分)进行了约束。但是线程依然有可能抛出unchecked exception（如运行时异常），当此类异常跑抛出时，线程就会终结，而对于主线程和其他线程完全不受影响，且完全感知不到某个线程抛出的异常(也是说完全无法catch到这个异常)。JVM的这种设计源自于这样一种理念：“线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部。”基于这样的设计理念，在Java中，线程方法的异常（无论是checked还是unchecked exception），都应该在线程代码边界之内（run方法内）进行try catch并处理掉.换句话说，我们不能捕获从线程中逃逸的异常。
看下面的例子：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExceptionThread implements Runnable {
    @Override
    public void run() {
        throw new RuntimeException("这个线程就干了这么一件事，抛出一个运行时异常");
    public static void main(String[] args) {
        try {
            ExecutorService exec = Executors.newCachedThreadPool();
            exec.execute(new ExceptionThread());
            System.out.println("该干嘛干嘛去");
        } catch (RuntimeException e) {
            System.out.println("能不能捕获到异常？");
运行结果：
 
该干嘛干嘛去
Exception in thread "pool-1-thread-1" java.lang.RuntimeException: 这个线程就干了这么一件事，抛出一个运行时异常
    at ExceptionThread.run(ExceptionThread.java:8)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
    at java.lang.Thread.run(Thread.java:619)
 
从运行结果中，我们可以看到的是，这个异常在main线程中没有catch到，即
 
  System.out.println("能不能捕获到异常？");
 
   永远不会执行到。
 
        问题来了，我们如果需要捕获其线程的unchecked异常时该怎么办？Java SE5之后，我们可以通过Executor来解决这个我问题。为了解决这个问题，我们需要修改Executor产生线程的方式。Thread.UncaughtExceptionHandler是java SE5中的新接口，它允许我们在每一个Thread对象上添加一个异常处理器。（UncaughtExceptionHandler）。Thread.UncaughtExceptionHandler.uncaughtException()方法会在线程因未捕获的异常而面临死亡时被调用。下面这个例子简单的演示了如何使用UncaughtExceptionHandler
 
 
public class ExceptionThread2 implements Runnable {
 
 
 
    @Override
 
    public void run() {
 
        Thread t = Thread.currentThread();
 
        System.out.println("run() by" + t);
 
        System.out.println("eh=" + t.getUncaughtExceptionHandler());
 
        throw new RuntimeException("抛出运行时异常");
 
    }
 
}
 
 
import java.lang.Thread.UncaughtExceptionHandler;
 * 用于捕获异常---捕获的是uncheckedException
 * @author February30th
public class MyUnchecckedExceptionhandler implements UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("捕获到异常：" + e);
import java.util.concurrent.ThreadFactory;
public class HandlerThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        System.out.println("创建一个新的线程");
        Thread t = new Thread(r);
        t.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        System.out.println("eh121 = " + t.getUncaughtExceptionHandler());
        return t;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadExceptionTest {
     * @param args
    public static void main(String[] args) {
        //下面有3中方式来执行线程。
        //第1种按照普通的方式。这是能捕获到异常
        Thread t = new Thread(new ExceptionThread2());
        t.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        t.start();
        //第2种按照现成池，直接按照thread方式,此时不能捕获到异常，为什么呢？因为在下面代码中创建了一个线程，且设置了异常处理器，
        //但是呢，在我们线程池中会重设置新的Thread对象，而这个Thread对象没有设置任何异常处理器，换句话说，我们在线程池外对线程做的
        //任何操作都是没有用的
        ExecutorService exec1 = Executors.newCachedThreadPool();
        Runnable runnable = new ExceptionThread2();
        Thread t1 = new Thread(runnable);
        t1.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        exec1.execute(runnable);
        //第3种情况一样的，也是走的线程池，但是呢是通过ThreadFactory方式，在ThreadFactory中会对线程做一些控制，可以设置异常处理器
        //此时是可以捕获异常的。
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
        exec.execute(new ExceptionThread2());
创建一个新的线程
eh121 = MyUnchecckedExceptionhandler@1b8e059
run() byThread[Thread-0,5,main]
eh=MyUnchecckedExceptionhandler@1b8e059
捕获到异常：java.lang.RuntimeException: 抛出运行时异常
 
从上述的运行结果中可以看到，未捕获的异常是通过uncaughtException来捕获的。
 
按照上述的实例，我们可以按照具体的情况，逐个地设置处理器。但是如果我们知道将要在代码的所有地方都是用相同的异常处理器，那么更简单的方式是在Thread类中设置一个静态域，并将这个处理器设置为默认的未捕获异常处理器。看下面的例子：
 
Thread.setDefaultUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
        exec.execute(new ExceptionThread2());
 
这个默认的处理器只有在线程不存在非默认的异常处理器时才会调用。 在运行时，系统会检查线程是否有属于自己的异常处理器，如果发现没有，就去检查相应的线程组是否有专有的异常处理器，如果发现也没有，再调用默认的异常处理器。
                    转自：https://www.cnblogs.com/chenfei0801/archive/2013/04/23/3039286.html在java多线程程序中，所有线程都不允许抛出未捕获的checked exception（比如sleep时的InterruptedException），也就是说各个线程需要自己把自己的checked exception处理掉。这一点是通过java.lang....
				
Java中所有异常的父类是Throwable类，在Throwable类下有两大子类：
一个是Error类，指系统错误异常，例如：VirtualMachineError 虚拟机错误，ThreadDeath 线程死锁。一般如果是Error类的异常的话，就是程序的硬伤，就好比是工厂里断水断电，机器损坏了。
另一个是Exception类，指编码、环境、用户操作输入等异常，这个是比较常见的异常类，Exc...
				
16/01/08 18:52:54 [main]: WARN hive.metastore: Failed to connect to the MetaStore Server...
org.apache.thrift.transport.TTransportException: java.net.ConnectException: Connection refused
				
在Java中，主线程可以捕获子线程抛出的异常。一种简单的方式是使用try-catch语句块来捕获异常。例如，假设有一个子线程MyThread如下：
public class MyThread extends Thread {
    public void run() {
        // some code that might throw an exception
在主线程中启动并等待子线程完成，可以这样做：
try {
    MyThread myThread = new MyThread();
    myThread.start();
    myThread.join(); // wait for the thread to finish
} catch (InterruptedException e) {
    // handle interrupt exception
} catch (Exception e) {
    // handle any other exception thrown by the thread
在这个例子中，如果子线程中抛出了一个异常，它会被主线程捕获并处理。注意，子线程抛出的异常必须是Throwable的子类，否则它不会被捕获。同时需要注意的是，捕获子线程异常的方式还有其他的实现方式，具体实现要根据实际情况而定。