逃逸的异常

package com.thread.exc;


public class ExceptionThread extends Thread
{
    @Override
    public void run()
    {
        System.out.println(11);
        throw new RuntimeException();
    }

    public static void main(String[] args)
    {
        try
        {
            new ExceptionThread().start();
        }
        catch (Exception e)
        {
           System.out.println("I caught it.");
        }
    }
}

捕获方式：
1.demo

package com.thread.exc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class CaptureUncaughtException
{
    public static void main(String[] args)
    {
        ExecutorService exec = Executors.newCachedThreadPool(new HandleThreadFactory());

        exec.execute(new ExceptionThread2());
    }
}

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

class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler
{
    @Override
    public void uncaughtException(Thread t, Throwable e)
    {
        System.out.println("caught " + e);
    }
}

class HandleThreadFactory implements ThreadFactory
{
    @Override
    public Thread newThread(Runnable r)
    {
        System.out.println(this + " creating new Thread...");
        Thread t = new Thread(r);
        System.out.println("created " + t);

        t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
        System.out.println("eh = " + t.getUncaughtExceptionHandler());
        return t;
    }
}

2.demo

package com.thread.exc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class CaptureUncaughtException
{
    public static void main(String[] args)
    {
        // ExecutorService exec = Executors.newCachedThreadPool(new HandleThreadFactory());
        //
        // exec.execute(new ExceptionThread2());
        /*
        *在Thread类中设置一个静态域，并将自定义未捕获异常处理器设置为默认的未捕获异常处理器。
        *它只有在不存在线程专有的未捕获异常处理器的情况下才会被调用，系统会检查专有版本，
        *如果没有发现，则检查线程组是否有专有的uncaughtException()方法，
        *如果依然没有，再调用defaultUncaughtExceptionHandler
        */
        Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());

        ExecutorService exec = Executors.newCachedThreadPool();

        exec.execute(new ExceptionThread2());
    }
}

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

class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler
{
    @Override
    public void uncaughtException(Thread t, Throwable e)
    {
        System.out.println("caught " + e);
    }
}

class HandleThreadFactory implements ThreadFactory
{
    @Override
    public Thread newThread(Runnable r)
    {
        System.out.println(this + " creating new Thread...");
        Thread t = new Thread(r);
        System.out.println("created " + t);

        t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
        System.out.println("eh = " + t.getUncaughtExceptionHandler());
        return t;
    }
}