public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime, 
    TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory，
    RejectedExecutionHandler handler){
     //...
}

exec.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

/**
 * 設(shè)置信號量的上界設(shè)置為線程池的大小加上可排隊任務(wù)的數(shù)量，控制正在執(zhí)行和等待執(zhí)行的任務(wù)數(shù)量。
 */
public class BoundedExecutor {
 
 private final Executor exec;
 private final Semaphore semaphore;
 
 public BoundedExecutor(Executor exec,int bound){
  this.exec = exec;
  this.semaphore = new Semaphore(bound);
 }
 
 public void submitTask(final Runnable task) throws InterruptedException{
  semaphore.acquire();
  try{
   exec.execute(new Runnable(){
    public void run(){
     try{
      task.run();
     }finally{
      semaphore.release();
     }
    }
   });
  }catch(RejectedExecutionException e){
   semaphore.release();
  }
 }
}

public interface ThreadFactory{
 Thread newThread(Runnable r);
}

// 示例：將一個特定于線程池的名字傳遞給MyThread的構(gòu)造函數(shù)，從而可以再線程轉(zhuǎn)儲和錯誤日志信息中區(qū)分來自不同線程池的線程。
 public class MyThreadFactory implements ThreadFactory{
 
 private final String poolName;
 
 public MyThreadFactory(String poolName){
  this.poolName = poolName;
 }
 
 public Thread newThread(Runnable runnable){
  return new MyThread(runnable,poolName);
 }
}

// 示例：為線程指定名字，設(shè)置自定義UncaughtExceptionHandler向Logger中寫入信息及維護一些統(tǒng)計信息以及在線程被創(chuàng)建或者終止時把調(diào)試消息寫入日志。
public class MyThread extends Thread{
 public static final String default_name = "myThread";
 private static volatile boolean debugLifecycle = false;
 private static final AtomicInteger created = new AtomicInteger();
 private static final AtomicInteger alive = new AtomicInteger();
 private static final Logger log = Logger.getAnonymousLogger();

 public MyThread(Runnable runnable){
  this(runnable,default_name);
 }

 public MyThread(Runnable runnable, String defaultName) {
  super(runnable,defaultName + "-" + created.incrementAndGet());
  setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
   @Override
   public void uncaughtException(Thread t, Throwable e) {
    log.log(Level.SEVERE,"uncaught in thread " + t.getName(), e); 

   }
  });
 }

 public void run(){
  boolean debug = debugLifecycle;
  if(debug){
   log.log(Level.FINE,"created " + getName());
  }
  try{
   alive.incrementAndGet();
   super.run();
  }finally{
   alive.decrementAndGet();
   if(debug){
    log.log(Level.FINE,"Exiting " + getName());
   }
  }

 }
}

/**
 * TimingThreadPool中給出了一個自定義的線程池，通過beforeExecute、afterExecute、terminated等方法來添加日志記錄和統(tǒng)計信息收集。
 * 為了測量任務(wù)的運行時間，beforeExecute必須記錄開始時間并把它保存到一個afterExecute可用訪問的地方。
 * 因為這些方法將在執(zhí)行任務(wù)的線程中調(diào)用，因此beforeExecute可以把值保存到一個ThreadLocal變量中。然后由afterExecute來取。
 * 在TimingThreadPool中使用了兩個AtomicLong變量，分別用于記錄已處理的任務(wù)和總的處理時間，并通過包含平均任務(wù)時間的日志消息。
 */
public class TimingThreadPool extends ThreadPoolExecutor{
 
 public TimingThreadPool(int corePoolSize, int maximumPoolSize,
   long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
  super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
 }
 
 private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
 private final Logger log = Logger.getLogger("TimingThreadPool");
 private final AtomicLong numTasks = new AtomicLong();
 private final AtomicLong totalTime = new AtomicLong();
 
 protected void beforeExecute(Thread t,Runnable r){
  super.beforeExecute(t, r);
  log.fine(String.format("Thread %s: start %s", t,r));
  startTime.set(System.nanoTime());
 }
 
 protected void afterExecute(Throwable t,Runnable r){
  try{
   long endTime = System.nanoTime();
   long taskTime = endTime - startTime.get();
   numTasks.incrementAndGet();
   totalTime.addAndGet(taskTime);
   log.fine(String.format("Thread %s: end %s, time=%dns", t,r,taskTime));
  }finally{
   super.afterExecute(r, t);
  }
 }
 
 protected void terminated(){
  try{
   log.info(String.format("Terminated: avg time=%dns", totalTime.get()/numTasks.get()));
  }finally{
   super.terminated();
  }
 }
}