线程池使用的N种姿势

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors返回的线程池对象的弊端如下：

• 1）FixedThreadPool和SingleThreadPool:

  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

• 2）CachedThreadPool:

  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

答案可以看下ThreadPoolExecutor类的上的注释,已翻译成中文：

为了在广泛的上下文中有用，此类提供了许多可调参数和可扩展性钩子。 然而，程序员被敦促使用更方便的Executors工厂方法Executors.newCachedThreadPool() （无限线程池，具有自动线程回收）， Executors.newFixedThreadPool(int) （固定大小的线程池）和Executors.newSingleThreadExecutor() （单个后台线程），可以预先配置最常用的使用场景设置。 否则，手动配置和调优此类时，请使用以下指南...

其实这个类的作者"Doug Lea"，已经说明Executors.newCachedThreadPool()，Executors.newFixedThreadPool(int)，应该是在什么情况下使用？
只是一般程序员是不会去仔细看类说明文档，都是跟着百度复制过来的代码就干起活来了，
说起来也惭愧之前在2010年培训的时候，其实是会看这个jdk api文档的，但那个时候似乎很懵，也不会去详尽的看文档背后的一些知识点。
所以说看第一手材料多么重要，作者已经把该注意的点都写到类说明文档注释里了，吓得我赶紧用到一个类都去细看下文档注释，解决不了再找度娘。

从几个面试题来一一道来。

1.核心和最大线程池是否都可以动态修改？
>可以使用setCorePoolSize(int)和setMaximumPoolSize(int)进行动态 更改

2.核心线程最初创建并且只有在新任务到达时才启动？
>可以使用方法prestartCoreThread()或prestartAllCoreThreads()动态地覆盖。如果您使用非空队列构建池，则可能需要预先提供线程。

3.核心线程是否一定不终止？
>不一定，报错或者allowCoreThreadTimeOut(boolean)也可以用于将这个超时策略应用于核心线程，只要keepAliveTime值不为零

4.如何给线程池添加一个启动/暂停的功能？

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
  private boolean isPaused;      
  private ReentrantLock pauseLock = new ReentrantLock();     
  private Condition unpaused = pauseLock.newCondition();     
     
  public PausableThreadPoolExecutor(...) { super(...); }     
     
  protected void beforeExecute(Thread t, Runnable r) {
    super.beforeExecute(t, r);   
    pauseLock.lock();     
    try {   
      while (isPaused) unpaused.await();
    } catch (InterruptedException ie) { 
      t.interrupt();      
    } finally {    
      pauseLock.unlock(); 
    }
  }  
     
  public void pause() {   
    pauseLock.lock();     
    try {   
      isPaused = true;    
    } finally {    
      pauseLock.unlock(); 
    }
  }  
     
  public void resume() {  
    pauseLock.lock();     
    try {   
      isPaused = false;   
      unpaused.signalAll();      
    } finally {    
      pauseLock.unlock(); 
    }
  }  
}}     

package org.springframework.scheduling.concurrent;

public class ThreadPoolExecutorFactoryBean extends ExecutorConfigurationSupport implements FactoryBean, InitializingBean, DisposableBean {
    private int corePoolSize = 1;
    private int maxPoolSize = 2147483647;
    private int keepAliveSeconds = 60;
    private boolean allowCoreThreadTimeOut = false;
    private int queueCapacity = 2147483647;
    private boolean exposeUnconfigurableExecutor = false;
    @Nullable
    private ExecutorService exposedExecutor;

    public ThreadPoolExecutorFactoryBean() {
    }
    ...
    protected ThreadPoolExecutor createExecutor(int corePoolSize, int maxPoolSize, int keepAliveSeconds, BlockingQueue queue, ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
 return new ThreadPoolExecutor(corePoolSize, maxPoolSize, (long)keepAliveSeconds, TimeUnit.SECONDS, queue, threadFactory, rejectedExecutionHandler);
    }

package org.springframework.scheduling.concurrent;

public class ScheduledExecutorFactoryBean extends ExecutorConfigurationSupport implements FactoryBean {
    private int poolSize = 1;
    @Nullable
    private ScheduledExecutorTask[] scheduledExecutorTasks;
    private boolean removeonCancelPolicy = false;
    private boolean continueScheduledExecutionAfterException = false;
    private boolean exposeUnconfigurableExecutor = false;
    @Nullable
    private ScheduledExecutorService exposedExecutor;

    public ScheduledExecutorFactoryBean() {
    }

	@Override
	public void run() {
		try {
			this.delegate.run();
		}
		catch (UndeclaredThrowableException ex) {
			this.errorHandler.handleError(ex.getUndeclaredThrowable());
		}
		catch (Throwable ex) {
			this.errorHandler.handleError(ex);
		}
	}