参考了《java并发编程实战》P134内容
每当线程池需要创建一个线程时，都是通过调用线程工厂方法来完成的，默认的线程工厂方法将创建一个新的、非守护的线程，并且不包好特殊的配置信息。
如果你希望在线程运行之前、之后、或者运行中如果发生异常等情况作一些人工干预的话，可以自定义线程工厂。
示例：
import java.util.concurrent.atomic.*;
import java.util.logging.*;
public class MyAppThread extends Thread {
public static final String DEFAULT_NAME = "MyAppThread";
private static final AtomicInteger created = new AtomicInteger();
private static final AtomicInteger alive = new AtomicInteger();
private static final Logger log = Logger.getAnonymousLogger();
public MyAppThread(Runnable r) {
this(r, DEFAULT_NAME);
}
public MyAppThread(Runnable runnable, String name) {
super(runnable, name + "-" + created.incrementAndGet());
this.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t,
Throwable e) {
log.log(Level.SEVERE, "UNCAUGHT in thread " + t.getName(), e);
}
});
}
public void run() {
System.out.println("Created " + getName());
try {
alive.incrementAndGet();
super.run();
} finally {
alive.decrementAndGet();
System.out.println("Exiting " + getName());
}
}
public static int getThreadsCreated() {
return created.get();
}
public static int getThreadsAlive() {
return alive.get();
}
}
import java.util.concurrent.*;
public class MyThreadFactory implements ThreadFactory {
private final String poolName;
public MyThreadFactory(String poolName) {
this.poolName = poolName;
}
public Thread newThread(Runnable runnable) {
return new MyAppThread(runnable, poolName);
}
}
测试类：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class MyThreadFactoryClient {
public static void main(String[] args) {
ExecutorService pool = new ThreadPoolExecutor(3, 3, 0L,
TimeUnit.MICROSECONDS, new LinkedBlockingQueue<Runnable>(),
new MyThreadFactory("ZJH"));
for (int i = 0; i < 10; i++) {
pool.execute(new MyThread("" + i));
}
pool.shutdown();
}
static class MyThread extends Thread {
public String name;
public MyThread(String name) {
this.name = name;
}
public void run() {
if("5".equals(name)){
throw new NullPointerException("5 is null");
}
System.out.println("Thread-" + name + " is running.....");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
扩展ThreadPoolExecutor ：
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
public class TimingThreadPool extends ThreadPoolExecutor {
public TimingThreadPool() {
super(1, 1, 0L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
}
private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
private final AtomicLong numTasks = new AtomicLong();
private final AtomicLong totalTime = new AtomicLong();
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
System.out.println(String.format("Thread %s: start %s", t, r));
startTime.set(System.nanoTime());
}
protected void afterExecute(Runnable r, Throwable t) {
try {
long endTime = System.nanoTime();
long taskTime = endTime - startTime.get();
numTasks.incrementAndGet();
totalTime.addAndGet(taskTime);
System.out.println(String.format("Thread %s: end %s, time=%dns",
t, r, taskTime));
} finally {
super.afterExecute(r, t);
}
}
protected void terminated() {
try {
System.out.println(String.format("Terminated: avg time=%dns",
totalTime.get() / numTasks.get()));
} finally {
super.terminated();
}
}
public static void main(String[] args) {
TimingThreadPool pool = new TimingThreadPool();
pool.execute(new Runnable(){
public void run() {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
pool.shutdown();
}
}