运行时异常的处理

package test.liuwei;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * @author liuwei
 * @date 2019-10-08 08:42
 * @desc 运行时异常的处理
 * 编程良好的代码需要处理任何可控的异常并尽量减少性能的损失
 */
@Slf4j
public class RuntimeExceptionHandler {

    private static Thread.UncaughtExceptionHandler UEH = new GlobalUncaughtExceptionHandler();

    //拥有固定大小线程池并指定线程工厂的任务执行器ExecutorService
    private final static int FIX_POOL_SIZE = 5;
    private final static ExecutorService EXECUTOR = Executors.newFixedThreadPool(FIX_POOL_SIZE,new GlobalThreadFactory());

    public static void main(String[] args) {
        threadPoolUEH();
    }

    /**
     * 主动捕获RuntimeException
     * 虽然捕获运行时异常混乱了代码逻辑，但胜过什么都不做时整个程序崩溃
     * 在很多情况下这是必要的，比如未完成的并发任务被其它线程取消时会报出CancellationException，该异常为运行时异常，应该优雅地退出
     * 是否需要主动捕获运行时异常视具体情况而定
     */
    private static void catchRE(){
        try {
            log.info("***"+1/0);
        }catch (RuntimeException e){
            log.info("捕获到运行时异常："+e);
        }
        log.info(">>>END<<<");
    }

    /**
     * 对线程指定未捕获异常的处理对象UncaughtExceptionHandler
     * 当JVM发现未捕获异常时，会将异常及其所在的线程对象响应到UEH对象
     * UEH对象可以进行日志记录、关闭整个应用程序或重启线程等任何所需操作
     */
    private static void threadUEH(){
        Thread.setDefaultUncaughtExceptionHandler(UEH);
        log.info("***"+1/0);
    }

    /**
     * 对线程池指定未捕获异常的处理对象UncaughtExceptionHandler
     * 推荐使用线程池，推荐为线程池中的每个线程指定运行时异常处理对象
     *
     * 特别注意：
     * 调度器的submit方法不会将运行时异常通知UEH处理，而且也不会抛出这些运行时异常，只是悄悄地结束，而且是成功结束
     * 应使用execute方法提交任务
     */
    private static void threadPoolUEH(){
        EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                log.info("***"+1/0);
            }
        });
        EXECUTOR.shutdown();
        log.info(">>>调度器关闭");
    }

}

/**
 * 全局异常处理器：处理所有未捕获的异常
 */
class GlobalUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        Logger logger = Logger.getAnonymousLogger();
        logger.log(Level.SEVERE,"线程["+t.getName()+"]终止，异常："+e);
    }
}

/**
 * 全局线程工厂类：用以为线程池创建线程，并指定每个线程的异常处理对象UncaughtExceptionHandler
 */
class GlobalThreadFactory implements ThreadFactory{
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    //线程的异常处理对象UncaughtExceptionHandler
    private static Thread.UncaughtExceptionHandler UEH = new GlobalUncaughtExceptionHandler();

    GlobalThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                Thread.currentThread().getThreadGroup();
        namePrefix = "我的线程池-thread-" +
                poolNumber.getAndIncrement() +
                "-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                namePrefix + threadNumber.getAndIncrement(),
                0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        //指定每个线程的异常处理对象UncaughtExceptionHandler
        t.setDefaultUncaughtExceptionHandler(UEH);
        return t;
    }
}