1. 线程池的创建

线程池的创建使用ThreadPoolExecutor类，有利于编码时更好的明确线程池运行规则。

     //构造函数/*** Creates a new {@code ThreadPoolExecutor} with the given initial* parameters.** @param corePoolSize the number of threads to keep in the pool, even*        if they are idle, unless {@code allowCoreThreadTimeOut} is set* @param maximumPoolSize the maximum number of threads to allow in the*        pool* @param keepAliveTime when the number of threads is greater than*        the core, this is the maximum time that excess idle threads*        will wait for new tasks before terminating.* @param unit the time unit for the {@code keepAliveTime} argument* @param workQueue the queue to use for holding tasks before they are*        executed.  This queue will hold only the {@code Runnable}*        tasks submitted by the {@code execute} method.* @param threadFactory the factory to use when the executor*        creates a new thread* @param handler the handler to use when execution is blocked*        because the thread bounds and queue capacities are reached* @throws IllegalArgumentException if one of the following holds:<br>*         {@code corePoolSize < 0}<br>*         {@code keepAliveTime < 0}<br>*         {@code maximumPoolSize <= 0}<br>*         {@code maximumPoolSize < corePoolSize}* @throws NullPointerException if {@code workQueue}*         or {@code threadFactory} or {@code handler} is null*/public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)throw new IllegalArgumentException();if (workQueue == null || threadFactory == null || handler == null)throw new NullPointerException();this.corePoolSize = corePoolSize;this.maximumPoolSize = maximumPoolSize;this.workQueue = workQueue;this.keepAliveTime = unit.toNanos(keepAliveTime);this.threadFactory = threadFactory;this.handler = handler;}

参数含义

(1) 核心线程数corePoolSize： 保持在池中的线程数

(2) 最大线程数maximumPoolSize

(3) 保活时间keepAliveTime： 线程数大于corePoolSize，闲置线程最大空闲时间

(4) 时间单位unit

(5) 阻塞队列workQueue
java.util.concurrent.BlockingQueue主要实现类有：

• ArrayBlockingQueue： 数组结构有界阻塞队列，FIFO排序。其构造函数必须设置队列长度。
• LinkedBlockingQueue：链表结构有界阻塞队列，FIFO排序。队列默认最大长度为Integer.MAX_VALUE,故可能会堆积大量请求，导致OOM。
  
• PriorityBlockingQueue：支持优先级排序的无界阻塞队列。默认自然顺序排列，可以通过比较器comparator指定排序规则。
• DelayQueue：支持延时获取元素的无界阻塞队列。队列使用PriorityQueue实现。

(6) 线程创建接口threadFactory

• 默认使用Executors.defaultThreadFactory()。
• 可以自定义ThreadFactory实现或使用第三方实现，方便指定有意义的线程名称。

import com.google.common.util.concurrent.ThreadFactoryBuilder; ...ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("my-pool-%d").build();

public class MyThreadFactory implements ThreadFactory {private final AtomicInteger threadNumber = new AtomicInteger(1);private final String namePrefix;MyThreadFactory(String namePrefix) {this.namePrefix = namePrefix+"-";}@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread( r,namePrefix + threadNumber.getAndIncrement());if (t.isDaemon()) {t.setDaemon(true);}if (t.getPriority() != Thread.NORM_PRIORITY) {t.setPriority(Thread.NORM_PRIORITY);}return t;}
}

(7) 饱和策略handler

• ThreadPoolExecutor.AbortPolicy()：终止策略(默认) ， 抛出java.util.concurrent.RejectedExecutionException异常。
• ThreadPoolExecutor.CallerRunsPolicy(): 重试添加当前的任务，他会自动重复调用execute()方法。
• ThreadPoolExecutor.DiscardOldestPolicy(): 抛弃下一个即将被执行的任务，然后尝试重新提交新的任务。最好不和优先级队列一起使用，因为它会抛弃优先级最高的任务。
• ThreadPoolExecutor.DiscardPolicy(): 抛弃策略， 抛弃当前任务。

2. 线程池的运行规则

execute添加任务到线程池:
一个任务通过execute(Runnable)方法被添加到线程池。任务是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

线程池运行规则:
当一个任务通过execute(Runnable)方法添加到线程池时：

• 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
• 如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
• 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

• 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

• 也就是：处理任务的优先级为：

  核心线程corePoolSize - > 任务队列workQueue - > 最大线程maximumPoolSize
  如果三者都满了，使用handler策略处理该任务。

• 当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

    // execute方法源码实现(jdk1.8)public void execute(Runnable command) {if (command == null)throw new NullPointerException();/** Proceed in 3 steps:** 1. If fewer than corePoolSize threads are running, try to* start a new thread with the given command as its first* task.  The call to addWorker atomically checks runState and* workerCount, and so prevents false alarms that would add* threads when it shouldn't, by returning false.** 2. If a task can be successfully queued, then we still need* to double-check whether we should have added a thread* (because existing ones died since last checking) or that* the pool shut down since entry into this method. So we* recheck state and if necessary roll back the enqueuing if* stopped, or start a new thread if there are none.** 3. If we cannot queue task, then we try to add a new* thread.  If it fails, we know we are shut down or saturated* and so reject the task.*/int c = ctl.get();if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;c = ctl.get();}if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();if (! isRunning(recheck) && remove(command))reject(command);else if (workerCountOf(recheck) == 0)addWorker(null, false);}else if (!addWorker(command, false))reject(command);}

3. 线程池的关闭

通过调用线程池的shutdown或shutdownNow方法来关闭线程池。

• shutdown：将线程池的状态设置成SHUTDOWN状态，然后interrupt空闲线程。
• shutdownNow：线程池的状态设置成STOP，然后尝试interrupt所有线程，包括正在运行的。

关于线程池状态，源码中的注释比较清晰：

再看一下源代码：

    // 在关闭中，之前提交的任务会被执行（包含正在执行的，在阻塞队列中的），但新任务会被拒绝。public void shutdown() {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {checkShutdownAccess();// 状态设置为shutdownadvanceRunState(SHUTDOWN);// interrupt空闲线程interruptIdleWorkers();onShutdown(); // hook for ScheduledThreadPoolExecutor} finally {mainLock.unlock();}// 尝试终止线程池tryTerminate();}

其中，interruptIdleWorkers()方法往下调用了interruptIdleWorkers(), 这里w.tryLock()比较关键。
中断之前需要先tryLock()获取worker锁，正在运行的worker tryLock()失败(runWorker()方法会先对worker上锁)，故正在运行的worker不能中断。

    // 尝试停止所有正在执行的任务，停止对等待任务的处理，并返回正在等待被执行的任务列表public List<Runnable> shutdownNow() {List<Runnable> tasks;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {checkShutdownAccess();// 状态设置为STOPadvanceRunState(STOP);// 停止所有线程  interruptWorkers逻辑简单些，循环对所有worker调用interruptIfStarted().(interrupt所有线程)interruptWorkers();tasks = drainQueue();} finally {mainLock.unlock();}tryTerminate();return tasks;}

4. 线程池的使用场合

（1）单个任务处理的时间比较短；
（2）需要处理的任务数量大；

5. 线程池大小的设置

可根据计算任务类型估算线程池设置大小：

cpu密集型：可采用Runtime.avaliableProcesses()+1个线程；
IO密集型：由于阻塞操作多，可使用更多的线程，如2倍cpu核数。

6 实现举例

场景: ftp服务器收到文件后，触发相关搬移/处理操作。

public class FtpEventHandler extends DefaultFtplet {@Overridepublic FtpletResult onUploadEnd(FtpSession session, FtpRequest request)throws FtpException, IOException {// 获取文件名String fileName = request.getArgument();Integer index = fileName.lastIndexOf("/");String realFileName = fileName.substring(index + 1);index = realFileName.lastIndexOf("\\");realFileName = realFileName.substring(index + 1);// **处理文件**ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 50, 10,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3));threadPool.execute(new fileSenderThread(realFileName));return FtpletResult.DEFAULT;}
}

Spring也提供了ThreadPoolTaskExecutor

     <!--spring.xml配置示例--><bean id="gkTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><property name="allowCoreThreadTimeOut" value="true"/><property name="corePoolSize" value="10"/><property name="maxPoolSize" value="50"/><property name="queueCapacity" value="3"/><property name="keepAliveSeconds" value="10"/><property name="rejectedExecutionHandler"value="#{new java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy()}"/><property name="threadNamePrefix" value="gkTaskExecutor"/></bean>//java代码中注入bean@Autowired  @Qualifier("gkTaskExecutor")  private ThreadPoolTaskExecutor gkTaskExecutor;  

end.