6-线程泄漏

线程泄漏

当单线程的控制台程序由于发生了一个未捕获的异常而终止时，程序将停止运行，并产生与程序正常输出非常不同的栈追踪信息，这与典型的程序输出不同，当一个程序发生了异常说明有不稳定的因素存在。如果在并发程序中线程失败就没那么容易发现了。栈追踪可能会从控制台输出，但是没有人会一直在看控制台，并且，当线程失败的时候，应用程序可能看起来仍在工作。就象程序能跑在50个线程的线程池上，也能够跑在49个线程的线程池上，区别在于50个人干的活要比49个人干的活多得多。

导致线程提前死亡的最主要原因是RuntimeException。由于这些异常表示出现了某种编程错误或者其它不可修复的错误，因此它们通常不会被捕获。它们不会在调用栈中逐层传递，而是默认地在控制台中输出栈追踪信息，并终止线程。

处理未捕获的异常

在Thread API中，同样提供了UncaughtExceptionHandler，它能检测出某个线程由于未捕获的异常而终结的情况。通过使用UncaughtExceptionHandler异常处理器就能有效地防止线程泄漏问题。

当一个线程由于未捕获异常而退出时，JVM会把这个事件报告给应用程序提供的UncaughtExceptionHandler异常处理器（如以下代码所示）。如果没有提供任何异常处理器，那么默认的行为是将栈追踪信息输出到System.err。

// UncaughtExceptionHandler 接口
public interface UncaughtExceptionHandler {
    void uncaughtException(Thread t, Throwable e);
}

异常处理器如何处理未捕获异常，取决于对服务质量的需求。最常见的响应方式是将一个错误信息以及相应的栈追踪信息写入应用程序日志中，如以下代码所示。异常处理器还可以采取更直接的响应，例如尝试重新启动线程，关闭应用程序，或者执行其他修复或诊断等操作。

// 将异常写入日志的 UncaughtExceptionHandler
public class UEHLogger implements Thread.UncaughtExceptionHandler {
    public void uncaughtException(Thread t, Throwable e) {
        Logger logger = Logger.getAnonymousLogger();
        logger.log(Level.SEVERE, "Thread terminated with exception：" + t.getName());
    }
}

在运行时间较长的应用程序中，通常会为所有线程的未捕获异常指定同一个异常处理器，并且该处理器至少会将异常信息记录到日志中。

单线程设置异常处理器

下面通过一个例子演示异常处理器的使用方式：

public class UEHTest {

    private static final Logger logger = Logger.getLogger("UEHTest");

    public static void main(String[] args) throws IOException  {
        MyThreadFactory mtf = new MyThreadFactory();
        Thread t = mtf.newThread(new Runnable() {
            @Override
            public void run() {
                for (int i=0; i<50 ; i++) {
                    if (i == 40) 
                        throw new RuntimeException("发生了未捕获异常");
                }
            }
        });
        t.start();
    }

    // 定义线程工厂，以产生设置异常处理器和编号的线程
    static class MyThreadFactory implements ThreadFactory {

        private final AtomicInteger threadCount = new AtomicInteger(0);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(new UEHLogger());
            t.setName("my-thread-" + threadCount.incrementAndGet());
            return t;
        }
    }

    // 定义一个异常处理器，当线程发生未捕获异常时记录日志
    static class UEHLogger implements UncaughtExceptionHandler {

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            logger.log(Level.SEVERE, t.getName() + " throwed exception...", e);
        }
    }
}

运行结果：

线程池设置异常处理器

要为线程池中的所有线程设置一个UncaughtExceptionHandler，需要为ThreadPoolExecutor的构造函数提供一个ThreadFactory。标准线程池允许当发生未捕获异常时结束线程，但由于使用了一个try-finally代码块来接收通知，因此当线程结束时，将有新的线程来代替它，如果没有提供未捕获异常处理器或者其它的故障通知机制，那么任务会悄悄失败，从而导致极大的混乱。

异常处理器结合线程池：

public class UEHThreadPoolTest {

    private static final Logger logger = Logger.getLogger("UEHThreadPoolTest");

    public static void main(String[] args) throws IOException {
        ThreadPoolExecutor tpe = new ThreadPoolExecutor(5, 5, 0L,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
                new MyThreadFactory());
        tpe.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    if (i == 40)
                        throw new RuntimeException("发生了未捕获异常");
                }
            }
        });
    }

    // 定义线程工厂，以产生设置异常处理器和编号的线程
    static class MyThreadFactory implements ThreadFactory {

        private final AtomicInteger threadCount = new AtomicInteger(0);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(new UEHLogger());
            t.setName("my-thread-" + threadCount.incrementAndGet());
            return t;
        }
    }

    // 定义一个异常处理器，当线程发生未捕获异常时记录日志
    static class UEHLogger implements UncaughtExceptionHandler {

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            logger.log(Level.SEVERE, t.getName() + " throwed exception...", e);
        }
    }
}

运行结果：

只有通过execute提交的任务，才能将它抛出的异常交给未捕获异常处理器。而通过submit提交的任务，无论是抛出的未检查异常还是已检查异常，都将被认为是任务返回状态的一部分。如果一个由submit提交的任务由于抛出了异常而结束，那么这个异常将被Future.get封装在ExecutionException中重新抛出。