处理线程泄露

原文：http://sunnylocus.iteye.com/blog/538282

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

　　导致线程死亡的的最主要的原因是RuntimeException。因为这些异常表明一个程序错误或者不可修复的错误，它们不着顺着栈的调用传递，此时，默认的行为是在控制台打印栈追踪的信息，并终止线程。

　　我们举个例子，将奴隶主比作是你写的程序，奴隶比作是线程。假如你是奴隶主，你手下有5名奴隶，你分派他们一项任务去将不断开采来的石头搬到某个地方。如果中途有奴隶逃跑，那么搬运石头的效率就会下降，如果你没有措施发现奴隶逃跑，最后连一个奴隶也没有了，没有人再去搬石头了。当你发现程序有问题，比如程序刚启动的时候处理速度很快，以后越跑越慢，最后完全停止了，你可能不知道问题出在哪儿，其实这都是因为线程泄露引起的。想解决奴隶逃跑问题，不难，给每个奴隶戴上个报警器，一逃跑报警器就给你发信息，告诉哪个奴隶，因为什么原因逃跑了，可以根据需要再增加一名奴隶，让搬石头的奴隶数量始终维持在5名或着将信息记录到文件，便于分析导致线程泄露的原意改进程序。ok,我们用代码说话

１、定义好报警器

Java代码  

1. package com.bill99.thread.test;  
2.   
3. import java.lang.Thread.UncaughtExceptionHandler;  
4.   
5. //将泄露的线程信息输出到控制台  
6. public class UEHLogger implements UncaughtExceptionHandler {  
7.     public void uncaughtException(Thread t, Throwable e) {  
8.         System.out.println(String.format("不好了，有奴隶逃跑了!奴隶姓名：%1$s,编号：%2$s,逃跑原因：%3$s", t.getName(),t.getId(),e.getMessage()));  
9.         System.out.println("还剩"+HelotPool.helotPool.getActiveCount()+"个奴隶");  
10.     }  
11. }  

  

２、我们先建立一个奴隶工厂，每名奴隶出工厂的时候都会有一个报警器

 　　　

Java代码  

1. package com.bill99.thread.test;  
2.   
3. import java.util.concurrent.ThreadFactory;  
4. //奴隶制造工厂  
5. public class HelotFactory implements ThreadFactory {  
6.     private volatile int helotId=0;//奴隶编号  
7.     //产生一个新奴隶  
8.     public Thread newThread(Runnable r) {  
9.         Thread helotThread = new Thread(r);  
10.         helotThread.setName("helot-Thread-"+gethelotId());//设置奴隶姓名  
11.         helotThread.setUncaughtExceptionHandler(new UEHLogger());//UEHLogger就是报警器  
12.         return helotThread;  
13.     }  
14.     private int gethelotId(){  
15.         return ++helotId;  
16.     }  
17. }  

 ３、奴隶逃跑测试,看看是否会触发报警器

Java代码  

1. package com.bill99.thread.test;  
2.   
3. import java.util.concurrent.ThreadFactory;  
4. //奴隶逃跑测试  
5. public class HelotEscapeTest {  
6.     private ThreadFactory factory = new HelotFactory();  
7.     private Thread helotThread = null;  
8.       
9.     public HelotEscapeTest(){  
10.         Runnable task = new Runnable() {  
11.             int stoneNum=1;  
12.             public void run() {  
13.                 while(!Thread.interrupted()){  
14.                     System.out.println(helotThread.getName()+" 搬第"+stoneNum+"块石头..");  
15.                     stoneNum++;  
16.                     try{  
17.                         Thread.sleep(500);  
18.                     } catch(InterruptedException e){e.printStackTrace();}  
19.                     if(stoneNum>100){  
20.                         throw new RuntimeException("又饿又累没力气搬石头了");  
21.                     }  
22.                 }  
23.             }  
24.         };  
25.         helotThread = factory.newThread(task);  
26.     }  
27.     //开始干活  
28.     public void startWork(){  
29.         helotThread.start();  
30.     }  
31.     public static void main(String[] args) {  
32.         HelotEscapeTest test = new HelotEscapeTest();  
33.         test.startWork();  
34.     }  
35. }  

 运行程序后，奴隶在搬完100块石头后不干了，报警器给出提示信息

   不好了，有奴隶逃跑了!奴隶姓名：helot-Thread-1,编号：7,逃跑原因：又饿又累没力气搬石头了

这样我就能找出线程泄露的原因了。如果在线程池中发生了泄露是否也能记录？

4、奴隶池测试

Java代码  

1. package com.bill99.thread.test;  
2.   
3. import java.util.Random;  
4. import java.util.concurrent.BlockingQueue;  
5. import java.util.concurrent.LinkedBlockingQueue;  
6. import java.util.concurrent.ThreadFactory;  
7. import java.util.concurrent.ThreadPoolExecutor;  
8. import java.util.concurrent.TimeUnit;  
9.   
10. public class HelotPoolTest {  
11.       
12.     public static ThreadPoolExecutor helotPool;  
13.     private int helotNum= 5;  //奴隶数  
14.     private Random random = new Random(100);  
15.       
16.     private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();  
17.       
18.     public HelotPoolTest() {  
19.         ThreadFactory factory = new HelotFactory();  
20.         helotPool = new ThreadPoolExecutor( helotNum,helotNum,1000,TimeUnit.SECONDS,queue,factory);  
21.     }  
22.     //分配任务  
23.     public void assignTask(){  
24.         final int MAX=100;  
25.         final int MIN=10;  
26.         Runnable task = null;  
27.         for(int j=0;j<20;j++){  
28.             task = new Runnable() {  
29.                 int stoneNum = random.nextInt(MAX - MIN + 1) + MIN;// 生成10~100范围的随机数  
30.                 public void run() {  
31.                     for (int i = 1; i <= stoneNum; i++) {  
32.                         System.out.println(Thread.currentThread().getName() + " 搬完"+ i + "块石头");  
33.                         if (i == 60) {  
34.                             throw new RuntimeException("搬完第60块石头不干了");  
35.                         }  
36.                         try{  
37.                             Thread.sleep(100);//休息下  
38.                         }catch(InterruptedException e){e.printStackTrace();}  
39.                     }  
40.                 }  
41.             };  
42.             queue.add(task);  
43.         }  
44.     }  
45.     //开始干活  
46.     public void startWork(){  
47.         helotPool.prestartAllCoreThreads();  
48.     }  
49.     public static void main(String[] args) {  
50.         HelotPoolTest pool = new HelotPoolTest();  
51.         pool.assignTask();  
52.         pool.startWork();  
53.     }  
54. }  

 程序启动，用Jprofiler监控，刚启动时会有5名奴隶干活不一会就会有线程退出，最后5个线程全部退，报警器对每个线程退出都能记录到导致线程退出的原因。标准的Executor实现是:

在需求不高时回收空闲的线程，在需求增加时添加新的线程，如果任务抛出了异常，就会用一个全新的工作线程取代出错的那个。

JDK文档是这么说的，不过通过Jprofiler监控只有在5名奴隶全部逃跑，没人干活的时候ThreadPoolExecutor才会生成一个新线程继续搬石头，并不是只要一个线程退出就会马上生成新线程去代替。