ThreadPoolExecutor优势与用法

优势：

第一：降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗
第二：提高响应速度，当任务到达时任务不需要等到线程创建就能立即执行
第三：提高线程的可管理性，使用线程池进行统一的分配，调优和监控

使用：

创建线程池：

new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,runnableTaskQueue,handler);
/*
  参数：
  corePoolSize（线程池的基本大小）:
  如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
  如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
  如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
  如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
  当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
  maximumPoolSize：线程池维护线程的最大数量
  keepAliveTime： 线程池维护线程所允许的空闲时间
  unit： 线程池维护线程所允许的空闲时间的单位
  workQueue： 线程池所使用的缓冲队列
  handler： 线程池对拒绝任务的处理策略
*/

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

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、
MICROSECONDS、
MILLISECONDS、
SECONDS。

workQueue常用的是：java.util.concurrent.ArrayBlockingQueue

handler有四个选择：

1.ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
2.ThreadPoolExecutor.CallerRunsPolicy()
当抛出RejectedExecutionException异常时，会调用rejectedExecution方法
(如果主线程没有关闭，则主线程调用run方法,源码如下
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
)
3.ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
4.ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

使用举例：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test1 {
    private static int produceTaskSleepTime = 2;   
    private static int produceTaskMaxNumber = 10;  

    public static void main(String[] args) {  

        // 构造一个线程池  
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,  
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),  
                new ThreadPoolExecutor.DiscardOldestPolicy());  

        for (int i = 1; i <= produceTaskMaxNumber; i++) {  
            try {  
                String task = "task@ " + i;  
                System.out.println("创建任务并提交到线程池中：" + task);  
                threadPool.execute(new ThreadPoolTask(task));  

                Thread.sleep(produceTaskSleepTime);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  

}
import java.io.Serializable;

public class ThreadPoolTask implements Runnable, Serializable {  
    private Object attachData;  
    ThreadPoolTask(Object tasks) {  
        this.attachData = tasks;  
    }  
    public void run() {      
        System.out.println("开始执行任务：" + attachData);      
        attachData = null;  
    }  
    public Object getTask() {  
        return this.attachData;  
    }  
}  

执行结果：
创建任务并提交到线程池中：task@ 1
开始执行任务：task@ 1
创建任务并提交到线程池中：task@ 2
开始执行任务：task@ 2
创建任务并提交到线程池中：task@ 3
开始执行任务：task@ 3
创建任务并提交到线程池中：task@ 4
开始执行任务：task@ 4
创建任务并提交到线程池中：task@ 5
开始执行任务：task@ 5
创建任务并提交到线程池中：task@ 6
开始执行任务：task@ 6
创建任务并提交到线程池中：task@ 7
开始执行任务：task@ 7
创建任务并提交到线程池中：task@ 8
开始执行任务：task@ 8
创建任务并提交到线程池中：task@ 9
开始执行任务：task@ 9
创建任务并提交到线程池中：task@ 10
开始执行任务：task@ 10