从Java5开始，Java提供了自己的线程池。线程池就是一个线程的容器，每次只执行额定数量的线程。ThreadPoolExecutor就是这样的线程池。
ThreadPoolExecutor有多个构造函数，以下以最简单的为例
/** * Creates a new {@code ThreadPoolExecutor} with the given initial * parameters and default thread factory and rejected execution handler. * It may be more convenient to use one of the {@link Executors} factory * methods instead of this general purpose constructor. * * @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. * @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} is null */ public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); } corePoolSize-核心线程池大小maximumPoolSize-线程池的最大大小keepAliveTime-线程数量大于corePoolSize时，线程的存活时间TimeUnit -是一个枚举，表示 keepAliveTime 的单位workQueue-存放任务的队列 线程池刚创建时，里面没有一个线程。任务队列作为参数传递。此时，就算队里里面有任务，线程池也不会立即执行当调用execute()方法添加一个方法时，线程池会做如下判断 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个如果在运行的线程数量大于或等于corePoolSize，那么这个任务将放到队列里面如果这个时候队列满了，而且正在运行的线程数量小于maximumPoolSize，那么创建线程运行这个任务如果队列满了，切正在运行的线程数量大于等于maximumPoolSize，那么就执行拒绝策略当一个线程完成任务时，它会从队列中取下一个任务来执行当一个线程无事可做，超过keepAliveTime时，线程池会判断如果当前运行的线程数大约corePoolSize，那么这个线程就会被停掉。所以线程池的所有任务完成后，它会最终收缩到corePoolSize大小此过程说明，并不是先加入的任务就一定会先执行。假设队列大小为10，corePoolSize为3，maximumPoolSize 为6那么当加入20个任务时.然后任务 4~13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务 17~20 则会抛出异常。执行的顺序是这样的：1,2,3,14,15,16,4,5,6,7,8,9,10,11,12,13
以下代码示例
public static void main(String[] args) { BlockingQueue queue = new LinkedBlockingDeque<>(); //ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,1, TimeUnit.DAYS,queue); ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,1,TimeUnit.DAYS,queue){ @Override protected void afterExecute(Runnable r, Throwable t){ System.out.println("Task finished."); } @Override protected void terminated(){ System.out.println("shutdown...."); } }; for (int i=0; i<20; i++){ executor.execute(new Runnable() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(String.format("thread %d finished", this.hashCode())); } }); } executor.shutdown(); }总结如下：
BlockingQueue 只是一个接口，常用的实现类有LinkedBlockingQueue 和 ArrayBlockingQueue。用LinkedBlockingQueue 的好处是在于没有大小限制。这样的话队列不会满，所以execute()不会抛出异常，而且线程池中运行的线程数不会超过corePoolSize个数，keepAliveTime 参数也就没有意义了。shutdown()方法不会阻塞。调用shutdown()方法之后，主线就马上结束了，而是线程池会继续运行直到所有任务执行完才会停止。如果不调用shutdown()方法，那么线程池会一直保存下去，以便随时添加新的任务。
java.util.concurrent.ThreadPoolExecutor 类提供了丰富的可扩展性。你可以通过创建它的子类来自定义它的行为。
ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,1,TimeUnit.DAYS,queue){ @Override protected void afterExecute(Runnable r, Throwable t){ System.out.println("Task finished."); } @Override protected void terminated(){ System.out.println("shutdown...."); } };除了可以添加任务执行前后的动作之外，ThreadPoolExecutor还允许你自定义当前任务执行失败后的执行策略。可以调用线程池的 setRejectedExecutionHandler() 方法，用自定义的RejectedExecutionHandler对象替换现有的策略。ThreadPoolExecutor提供了4个现有的策略，分别是：
ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常 ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作 ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。
可以通过如下两种方式设置拒绝策略
ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,1,TimeUnit.DAYS,queue); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy()); executor = new ThreadPoolExecutor(3,6,1,TimeUnit.DAYS,queue,new ThreadPoolExecutor.AbortPolicy());除此之外也可以通过实现RejectedExecutionHandler 来自定义拒绝策略 代码如下
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.SECONDS, queue, new RejectedExecutionHandler() { public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { System.out.println(String.format("Task %d rejected.", r.hashCode())); } } );