public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

    } 

public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));

    } 

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();  

 public ThreadPoolExecutor(int corePoolSize,

                     int maximumPoolSize,

                     long keepAliveTime,

                     TimeUnit unit,

                     BlockingQueue<Runnable> workQueue) {

    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

        Executors.defaultThreadFactory(), defaultHandler);

}

四、ExecutorService任务周期管理接口

public interface ExecutorService extends Executor {

    void shutdown();

    List<Runnable> shutdownNow();

    boolean isShutdown();

    boolean isTerminated();

    boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

    // 省略部分方法

}

public class ExecutorServiceTest {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();

        List<Future<String>> resultList = new ArrayList<Future<String>>();  

        // 创建10个任务并执行

        for (int i = 0; i < 10; i++) {

            // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中

            Future<String> future = executorService.submit(new TaskWithResult(i));

            // 将任务执行结果存储到List中

            resultList.add(future);

        }

        executorService.shutdown();  

        // 遍历任务的结果

        for (Future<String> fs : resultList) {

            try {

                System.out.println(fs.get()); // 打印各个线程（任务）执行的结果

            } catch (InterruptedException e) {

                e.printStackTrace();

            } catch (ExecutionException e) {

                e.printStackTrace();

            }  finally {

　　　　　　　　executorService.shutdownNow();

　　　　　　　}

        }

    }

}  

class TaskWithResult implements Callable<String> {

    private int id;  

    public TaskWithResult(int id) {

        this.id = id;

    }  

    /**

     * 任务的具体过程，一旦任务传给ExecutorService的submit方法，则该方法自动在一个线程上执行。

     *

     * @return

     * @throws Exception

     */

    public String call() throws Exception {

        System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());

        if (new Random().nextBoolean())

            throw new TaskException("Meet error in task." + Thread.currentThread().getName());

        // 一个模拟耗时的操作

        for (int i = 999999999; i > 0; i--)

            ;

        return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();

    }

}  

class TaskException extends Exception {

    public TaskException(String message) {

        super(message);

    }

}

1. private final BlockingQueue<Runnable> workQueue;              // 阻塞队列

  2. private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁

  3. private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程

  4. private final Condition termination = mainLock.newCondition();// 终止条件

  5. private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值。

  6. private long completedTaskCount;       // 已完成任务数量

  7. private volatile ThreadFactory threadFactory;     // ThreadFactory对象，用于创建线程。

  8. private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄

  9. private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间

  10. private volatile boolean allowCoreThreadTimeOut;

  11. private volatile int corePoolSize;     // 线程池维护线程的最小数量，哪怕是空闲的

  12. private volatile int maximumPoolSize;  // 线程池维护的最大线程数量

3、ThreadFactory

　　使用 ThreadFactory 创建新线程。通过提供不同的 ThreadFactory，可以改变线程的名称、线程组、优先级、守护进程状态等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程，则执行程序将继续运行，但不能执行任何任务。

public interface ThreadFactory {

    Thread newThread(Runnable r);

}

而构造方法中的threadFactory对象，是通过 Executors.defaultThreadFactory()返回的。

4、RejectedExecutionHandler