ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue
RejectedExecutionHandler handler)
 
corePoolSize: 线程池维护线程的最少线程数,也是核心线程数,包括空闲线程
maximumPoolSize: 线程池维护线程的最大线程数
keepAliveTime: 线程池维护线程所允许的空闲时间
unit: 程池维护线程所允许的空闲时间的单位
workQueue: 线程池所使用的缓冲队列
handler: 线程池对拒绝任务的处理策略

try {  
    w = new Worker(firstTask);  
    final Thread t = w.thread;  
    if (t != null) {  
        final ReentrantLock mainLock = this.mainLock;  
        mainLock.lock();  
        try {  
            // Recheck while holding lock.  
            // Back out on ThreadFactory failure or if  
            // shut down before lock acquired.  
            int rs = runStateOf(ctl.get());  
  
            if (rs < SHUTDOWN ||  
                (rs == SHUTDOWN && firstTask == null)) {  
                if (t.isAlive()) // precheck that t is startable  
                    throw new IllegalThreadStateException();  
                workers.add(w);  
                int s = workers.size();  
                if (s > largestPoolSize)  
                    largestPoolSize = s;  
                workerAdded = true;  
            }  
        } finally {  
            mainLock.unlock();  
        }  
        if (workerAdded) {  
            t.start();  
            workerStarted = true;  
        }  
    }  
} finally {  
    if (! workerStarted)  
        addWorkerFailed(w);  
}  

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

ExectorService exector = Exectors.newCachedThreadPool();
exector.execute(new Runnable(){
public void run(){
System.out.println("running...");
}
});

ExectorService exector = Exectors.newCachedThreadPool();
Callable<Result> task = new Callable<Result>() {
    public Result call() {
        return new Computor().compute();
    }
};
Future<Result> future = exector.submit(task);
result = future.get();  //改方法会一直阻塞，直到提交的任务被运行完毕

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

public class Test {

    public static void main(String[] args) {
        TimingThreadPool executor = new TimingThreadPool(5, 10, 1,
                TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
        for (int i = 0; i < 5; i++)
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("running1....");
                }
            });
        executor.shutdown();
    }
}

class TimingThreadPool extends ThreadPoolExecutor {

    private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
    private final AtomicLong numTasks = new AtomicLong();
    private final AtomicLong totalTime = new AtomicLong();

    public TimingThreadPool(int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        startTime.set(System.nanoTime());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        try {
            long endTime = System.nanoTime();
            long taskTime = endTime - startTime.get();
            numTasks.incrementAndGet();
            totalTime.addAndGet(taskTime);
        } finally {
            super.afterExecute(r, t);
        }
    }

    @Override
    protected void terminated() {
        try {
            System.out.println(String.format("Terminated: arg time = %d",
                    totalTime.get() / numTasks.get()));
        } finally {
            super.terminated();
        }
    }
}