JDK线程池：Executors.newFixedThreadPool ， Executors.newSingleThreadExecutor，由一个ThreadFactory来创建新的线程，默认情况下为Executors.defaultThreadFactory(),ThreadFactory接口：

1. public interface ThreadFactory {  
2.     Thread newThread(Runnable r);  
3. } 

我们可以采用自定义的ThreadFactory工厂，增加对线程创建与销毁等更多的控制，

一个简单的例子，跟踪线程的创建与销毁：

1. package org.guojje.threadpool;  
2.  
3. import java.util.concurrent.atomic.AtomicInteger;  
4.  
5. public class WorkThread extends Thread {  
6.  
7.     private Runnable target;  
8.     private AtomicInteger counter;  
9.  
10.     public WorkThread(Runnable target, AtomicInteger counter) {  
11.         this.target = target;  
12.         this.counter = counter;  
13.     }  
14.  
15.     @Override 
16.     public void run() {  
17.         try {  
18.             target.run();  
19.         } finally {  
20.             int c = counter.getAndDecrement();  
21.             System.out.println("terminate no " + c + " Threads");  
22.         }  
23.     }  
24. } 

1. package org.guojje.threadpool;  
2.  
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.ThreadFactory;  
6. import java.util.concurrent.TimeUnit;  
7. import java.util.concurrent.atomic.AtomicInteger;  
8.  
9. public class MyThread implements Runnable {  
10.       
11.       
12.     public static void main(String[] args) {  
13.        ExecutorService ctp =  Executors.newCachedThreadPool(new ThreadFactory() {  
14.             private AtomicInteger count = new AtomicInteger();  
15.             public Thread newThread(Runnable r) {  
16.                 int c = count.incrementAndGet();  
17.                 System.out.println("create no " + c + " Threads");  
18.                 return new WorkThread(r,count);  
19.                   
20.             }  
21.         });  
22.          
23.        ctp.execute(new MyThread());  
24.        ctp.execute(new MyThread());  
25.        ctp.execute(new MyThread());  
26.        ctp.execute(new MyThread());  
27.        ctp.execute(new MyThread());  
28.        ctp.execute(new MyThread());  
29.          
30.        ctp.shutdown();  
31.         try {  
32.             ctp.awaitTermination(1200, TimeUnit.SECONDS);  
33.         } catch (InterruptedException e) {  
34.             e.printStackTrace();  
35.         }  
36.     }  
37.       
38.     public void run(){  
39.         System.out.println("complete a task!!!");  
40.     }  
41. }  

可以看到在执行这个过程中，共创建过几个线程。

本文转自 anranran 51CTO博客，原文链接:http://blog.51cto.com/guojuanjun/650981