Java多线程探索（一）：为什么要使用ThreadPoolExecutor？

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
	  // 这里底层使用的是ThreadPoolExecutor
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public class TestThreadFactory implements ThreadFactory {

    /**
     * 姓名前缀
     */
    private final String namePrefix;

    private final AtomicInteger nextId = new AtomicInteger(0);

    public TestThreadFactory(String whatFeatureOfGroup){
        this.namePrefix = "From TestThreadFactory's " + whatFeatureOfGroup + "-Worker-";
    }

    @Override
    public Thread newThread(Runnable task) {
        String name = namePrefix
                + nextId.getAndIncrement();
        Thread thread = new Thread(null, task, name, 0);
        System.out.println(thread.getName());
        return thread;
    }
}

public class ThreadPoolManager {

    /**
     * 核心线程大小
     */
    private int corePoolSize;
    /**
     * 最大线程池大小
     */
    private int maximumPoolSize;
    /**
     * 保持时间
     */
    private int keepAliveTime;

    /**
     * 时间单位
     */
    private TimeUnit timeUnit;

    /**
     * 阻塞队列
     */
    private BlockingQueue blockingQueue;

    /**
     * 线程工厂
     */
    private ThreadFactory threadFactory;

    /**
     * 线程饱和策略
     */
    private RejectedExecutionHandler handler;

    /**
     * 构造函数
     *
     * @param corePoolSize
     * @param maximumPoolSize
     * @param keepAliveTime
     * @param timeUnit
     * @param blockingQueue
     * @param threadFactory
     * @param handler
     */
    public ThreadPoolManager(int corePoolSize, int maximumPoolSize, int keepAliveTime, TimeUnit timeUnit, BlockingQueue blockingQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler){
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.keepAliveTime = keepAliveTime;
        this.timeUnit = timeUnit;
        this.blockingQueue = blockingQueue;
        this.threadFactory = threadFactory;
        this.handler = handler;
    }


    /**
     * 创建线程池
     *
     * @return
     */
    public ThreadPoolExecutor createThreadPool(){
        return new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, timeUnit, blockingQueue, threadFactory, handler);
    }
}

public class TestMain {

    public static void main(String[] args) {
        ThreadPoolManager threadPoolManager = new ThreadPoolManager(1,2,3,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(3), new TestThreadFactory("测试"), new ThreadPoolExecutor.AbortPolicy());
        ThreadPoolExecutor threadPoolExecutor = threadPoolManager.createThreadPool();
        for(int i = 0; i<5; i++){
            try {
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " test is running");
                    try {
						   // 用于更方便的看清执行情况
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}