ThreadPoolExecutor-线程池开发的使用

好久没有写过笔记了，最近做的一个项目涉及打线程池和队列的开发，觉得在这个项目中学习到的还是挺多的，对线程安全，并发的知识有加深认知；当然，现在用过的东西并不是代表以后还能娴熟的使用，做好笔记非常重要；

1：必须明白为什么要使用线程池：(这点很重要)

　　a:手上项目所需，因为项目主要的目的是实现多线程的数据推送；需要创建多线程的话，那就要处理好线程安全的问题；因为项目需要，还涉及到排队下载的功能，所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能；

　　b:在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题（这段是摘自网络）

2：如何创建一个线程池：

　　

 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;
    }

这里只是创建线程池其中的一个构造函数；其实其他的构造函数最终还是调用的这个构造函数；

说明一下这些参数的作用:

corePoolSize：核心池的大小，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中;

maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；这个参数是跟后面的阻塞队列联系紧密的；只有当阻塞队列满了，如果还有任务添加到线程池的话，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务；如果继续添加任务到线程池，且线程池中的线程数已经达到了maximumPoolSize，那么线程就会就会执行reject操作（这里后面会提及到）

keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止；默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用；即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法并设置了参数为true，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的阻塞队列大小为0；（这部分通过查看ThreadPoolExecutor的源码分析--getTask()部分）；

unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性（时间单位）

workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择　　

　　ArrayBlockingQueue;

　　LinkedBlockingQueue;

　　SynchronousQueue;

　　ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

threadFactory：线程工厂，主要用来创建线程：默认值 DefaultThreadFactory；

handler：表示当拒绝处理任务时的策略，就是上面提及的reject操作；有以下四种取值：

　　ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。（默认handle）

　　ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

　　ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

　　ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

3：对线程池的基本使用及其部分源码的分析（注意：这里的源码分析是基于jdk1.6；）

a:线程池的状态 

volatile int runState;
static final int RUNNING = 0; 运行状态
static final int SHUTDOWN = 1; 关闭状态；SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕
static final int STOP = 2;停止状态；此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务
static final int TERMINATED = 3;终止状态；当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态

b:参数再次说明。这是摘自网络的解释，我觉得他比喻的很好，所以这里直接就用它的解释

　　这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。

　　corePoolSize在很多地方被翻译成核心池大小，其实我的理解这个就是线程池的大小。举个简单的例子：

　　假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。

　　因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做；

　　当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待；

　　如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来；

　　然后就将任务也分配给这4个临时工人做；

　　如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。

　　当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。

　　这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。

　　也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量突然过大时的一种补救措施。

　　不过为了方便理解，在本文后面还是将corePoolSize翻译成核心池大小。

　　largestPoolSize只是一个用来起记录作用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。

c:添加线程池任务的入口就是execute();

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();//任务为空时抛出异常
    //如果线程池线程大小小于核心线程，就新建一个线程加入任务并启动线程
    //如果线程池线程大小大于核心线且且添加任务到线程失败，就把任务添加到阻塞队列
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {//新建线程并启动
        if (runState == RUNNING && workQueue.offer(command)) {//添加任务到队列
            if (runState != RUNNING || poolSize == 0)
                ensureQueuedTaskHandled(command);//添加到队列失败或已满，做拒接任务处理策略
        }
        //若阻塞队列失败或已满；这里新建一个线程并启动做应急处理（这里就是用到了maximumPoolSize参数）
        else if (!addIfUnderMaximumPoolSize(command))
            reject(command); // 若线程池的线程超过了maximumPoolSize；就做拒绝处理任务策略
    }
}

-->>继续跟踪代码到addIfUnderCorePoolSize(Runnable firstTask)：函数名称就可以看出来这个函数要执行的什么；如果线程池的线程小于核心线程数corePoolSize就新建线程加入任务并启动线程【在今后的开发中尽量把需要做的功能在函数名体现出来】

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;//获取当前线程池的锁
        mainLock.lock();//加锁
        try {
            /*
            这里线程池线程大小还需要判断一次；前面的判断过程中并没有加锁，因此可能在execute方法判断的时候poolSize小于corePoolSize，而判断完之后，在其他线程中又向线程池提交了任务，就可能导致poolSize不小于corePoolSize了，所以需要在这个地方继续判断
            */
            if (poolSize < corePoolSize && runState == RUNNING)
                t = addThread(firstTask);//新建线程
        } finally {
            mainLock.unlock();
        }
        if (t == null)
            return false;
        t.start();//若创建线程超过，就启动线程池的线程
        return true;
    }
    private Thread addThread(Runnable firstTask) {
        Worker w = new Worker(firstTask);//worker：ThreadPoolExecutor的内部类；
        Thread t = threadFactory.newThread(w);//使用线程工厂创建一个线程
        if (t != null) {
            w.thread = t;
            workers.add(w);//保存线程池正在运行的线程
            int nt = ++poolSize;//线程池的线程数加1
            if (nt > largestPoolSize)
                largestPoolSize = nt;
        }
        return t;
    }

-->>接下来定位worker类，看看线程池里的线程是如何执行的

上面的addIfUnderCorePoolSize(..)已经把线程启动了；现在就直接查看worker 的run()方法了

public void run() {
    try {
        Runnable task = firstTask;//该线程的第一个任务，执行完后就从阻塞队列取任务执行
        firstTask = null;
        while (task != null || (task = getTask()) != null) {//getTask()从队列去任务执行
            runTask(task);//线程执行任务
            task = null;
        }
    } finally {
        workerDone(this);//若任务全部执行完，就开始尝试去停止线程池；这部分代码就不再追踪下去，有兴趣的读者可以自己打开源码分析，不必害怕，学习大神们的编码方式，看源码能让你学习到很多
    }
}
 private void runTask(Runnable task) {
    final ReentrantLock runLock = this.runLock;
    runLock.lock();
    try {
         //多次检查线程池有没有关闭
        if (runState < STOP &&
            Thread.interrupted() &&
            runState >= STOP)
            thread.interrupt();

        boolean ran = false;
        //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务之前的统计工作或者用来保存正在执行的任务
        beforeExecute(thread, task);
        try {
            task.run();
            ran = true;
            //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务完成之后的统计工作或者用来保存正在执行的任务
            afterExecute(task, null);
            ++completedTasks;//统计总共执行的任务数
        } catch (RuntimeException ex) {
            if (!ran)
                afterExecute(task, ex);
            throw ex;
        }
    } finally {
        runLock.unlock();
    }
}

至此线程池基本的流程完了；

再说说我在项目中的使用：

MyExtendThreadPoolExecutor 继承了 ThreadPoolExecutor，并覆盖了其中的一些方法

public class MyExtendThreadPoolExecutor extends ThreadPoolExecutor{
    public static Logger logger=LoggerFactory.getLogger(MyExtendThreadPoolExecutor.class);
    /**
     * 记录运行中任务
     */
    private LinkedBlockingQueue<Runnable> workBlockingQueue=new  LinkedBlockingQueue<Runnable>();

    public MyExtendThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        workBlockingQueue.add((GtdataBreakpointResumeDownloadThread)r);//保存在运行的任务
        logger.info("Before the task execution");
    }
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        workBlockingQueue.remove((GtdataBreakpointResumeDownloadThread)r);//移除关闭的任务
        logger.info("After the task execution");
    }
    /**
     *
    * Description: 正在运行的任务
    * @return LinkedBlockingQueue<Runnable><br>
    * @author lishun
     */
    public LinkedBlockingQueue<Runnable> getWorkBlockingQueue() {
        return workBlockingQueue;
    }
}

MyExtendThreadPoolExecutor pool = new MyExtendThreadPoolExecutor(3, 3,60L,TimeUnit.SECONDS,new LinkedBlockingQueue <Runnable>()); //创建线程池

public void addToThreadPool(DownloadRecord downloadRecord){
    BlockingQueue<Runnable> waitThreadQueue = pool.getQueue();//Returns the task queue
    LinkedBlockingQueue<Runnable> workThreadQueue =pool.getWorkBlockingQueue();//Returns the running work
    GtdataBreakpointResumeDownloadThread downloadThread =
            new GtdataBreakpointResumeDownloadThread(downloadRecord);//需要执行的任务线程

    if (!waitThreadQueue.contains(downloadThread)&&!workThreadQueue.contains(downloadThread)) {//判断任务是否存在正在运行的线程或存在阻塞队列，不存在的就加入线程池（这里的比较要重写equals()）
        Timestamp recordtime = new Timestamp(System.currentTimeMillis());
        logger.info("a_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" add to  workThreadQueue");
        downloadThread.setName("th_"+downloadRecord.getName());
        pool.execute(downloadThread);//添加到线程池
    }else{
        logger.info("i_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" in  waitThreadQueue or workThreadQueue");
    }
}