ThreadPoolExecutor的分析与使用

        关于ThreadPoolExecutor的分析已经有很多,比较著名的诸如支付宝 清英 的聊聊并发(三)Java线程池的分析和使用,饭饭泛的《深入浅出 Java Concurrency》等,对于ThreadPoolExecutor的分析和介绍已经非常的清楚,但是博主笨拙,对于ThreadPoolExecutor源码研读了一段时间之后才理解其中的奥妙所在,本博客主要从以下两个方面ThreadPoolExecutor进行介绍,①、ThreadPoolExecutor当中corePoolSize中线程的保持,即ThreadPoolExecutor源码当中介绍的 常驻线程池当中的线程(corePoolSize the number of threads to keep in the pool, even if they are idle.);②、ThreadPoolExecutor当中keepAliveTime线程保活时间的使用(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.);③、参考《Java并发编程实战》和清英大神设计的ThreadPoolExecutor工具类。

1 ThreadPoolExecutor的状态流转

        ThreadPoolExecutor共有四种状态,RUNNING、SHUTDOWN、STOP、TERMINATED,这四种状态下,ThreadPoolExecutor对任务的处理流程如下:
  • RUNNING:接受新任务并且处理任务队列当中的任务
  • SHUTDOWN:不接受新任务,但是处理任务队列当中的任务
  • STOP :不接受新任务,并且不处理任务队列当中的任务,中断正在处理的线程     
  • TERMINATED:同STOP类似,并且所有的线程都已经被中断

        四种状态的转换图如下:

ThreadPoolExecutor的分析与使用_第1张图片

2 ThreadPoolExecutor对任务的处理流程

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);
                //如果线程池不处于运行中或任务无法放入队列,并且当前线程数量小于最大允许的线程数量,则创建一个线程执行任务。
            } else if (!addIfUnderMaximumPoolSize(command))
                //拒绝任务
                reject(command); // is shutdown or saturated
        }
    }
        ThreadPoolExecutor处理任务的具体流程图如下:
ThreadPoolExecutor的分析与使用_第2张图片

3 ThreadPoolExecutor当中核心线程池的保持及keepAliveTime线程保活时间的使用

        有了以上两点后,我们来看一下ThreadPoolExecutor核心线程池的保持方法和keepAliveTime的应用方法。我们还是从ThreadPoolExecutor.execute(task);方法入手,首先我们建立线程池之后会调用ThreadPoolExecutor.execute(task)方法,如果当前线程数小于核心线程数,则调用
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
当中的addIfUnderCorePoolSize()方法,
 private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        //其他操作
        Thread t = null;
        t = addThread(firstTask);
        t.start();//在这里开启线程执行任务,执行的其实是封装了任务的worker!
        //其他操作
    }
        addIfUnderCorePoolSize方法会调用addThread方法得到一个线程,然后开启这个线程。addThread方法如下:
 private Thread addThread(Runnable firstTask) {
        //使用Worker对任务进行封装
        Worker w = new Worker(firstTask);
        //获得线程,并将此线程关联到Worker而非firstTask(这里是要注意的一点!)
        Thread t = threadFactory.newThread(w);
        if (t != null) {
            //将线程赋值为Worker中的引用
            w.thread = t;
            //放入任务队列
            workers.add(w);
            //线程池当中线程的数量+1
            int nt = ++poolSize;
            if (nt > largestPoolSize)
                largestPoolSize = nt;
        }
        return t;
    }
        通过addThread方法,我们知道,线程所关联的任务不是外部所定义的原生任务,而是包装了任务的Worker,所以在addIfUnderCorePoolSize中所执行的t.start()方法,开启的是Worker当中的run()方法,而非原生任务当中的run方法。我们来看一下Worker当中的run()方法。
 public void run() {
            try {
                Runnable task = firstTask; //在核心线程数之下时,其不为空;
                firstTask = null;
		//无限循环获取工作队列里的任务来执行  getTask()是核心线程的保持和多余核心线程keepAliveTime时间的保活的关键点!!!
                while (task != null || (task = getTask()) != null) {
		     //不断的执行任务
                    runTask(task);
                    task = null;
                }
            } finally {
                workerDone(this);//线程完成工作之后,就会从线程队列当中删除。前提是退出上面的while循环!要看懂getTask()方法!!
            }
        }
        通过Work的run()方法,我们可以知道,一个线程开启之后,就不断的循环,从任务队列当中取任务,做任务。而这里的关紧点就在while循环当中的getTask方法。
Runnable getTask() {
        for (;;) {
            try {
                int state = runState;
                if (state > SHUTDOWN)//如果当前状态值大于SHUTDOWN,即为STOP或TERMINATED,这是返回null,不执行任务!
                    return null;
                Runnable r;
                if (state == SHUTDOWN)  // 如果线程池已经shutdown了,则从任务队列当中取任务。
                    r = workQueue.poll();
		   //当前线程数超出了核心线程池线程数时,才对超出核心线程的线程采用keepAliveTime保活策略
                else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
		   //keepAliveTime保活的关键。最长等待keepAliveTime时间,在此期间,如果有任务则返回任务。
		   //如果在keepAliveTimes时间内没有元素返回,而超出了等待时间超出了keepAliveTime,则返回 null
                    r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
                else
		   //当前线程数没有超出了核心线程池线程数时,一直等待到有任务返回! 
                    r = workQueue.take();
                if (r != null)
                    return r;
                if (workerCanExit()) {
                    if (runState >= SHUTDOWN) // Wake up others
                        interruptIdleWorkers();
                    return null;
                }
                // Else retry
            } catch (InterruptedException ie) {
                // On interruption, re-check runState
            }
        }
    }
        整个核心线程池的保持和多余线程的保活操作的 实现都基于阻塞队列workQueue实现,当前线程数小于核心线程数时,核心线程池当中的线程一直阻塞等待任务的到来,等任务来了之后,getTask()返回就不为null,这样,线程就可以开始做任务,而不用执行workerDone()方法,将自己从线程池当中移除出去。而线程数大于核心线程池数时,线程获得任务的时间是有限制的,在keepAliveTime时间内,如果线程得不到任务的话,就会返回,这样getTask()任务返回为null,执行workerDone()方法,将自己从线程池当中删除!过程图如下:
ThreadPoolExecutor的分析与使用_第3张图片

4 ThreadPoolExecutor在项目当中的使用实例

        一般一个项目当中最好配置一个公用的线程池工具类,这样的话,项目中需要开启线程时,从线程池当中取即可,减少随意出现线程创建,线程的关闭,线程切换所带来的性能开销。参考《Java并发编程实战》和清英大神设计的ThreadPoolExecutor工具类如下:
package com.yang.thread;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

import org.apache.log4j.Logger;

/**
 * @author Yangzl2008
 */
public class ThreadPoolManager {
    /**
     * 定时执行线程个数*
     */
    private final static int minSchedule = 1;
    /**
     * 核心线程个数 IO密集型设置为:2*Ncpu   CPU密集型设置为:Ncpu+1 *
     */
    private static int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;
    /**
     * 最大线程个数 设置为50个线程 *
     */
    private static int maximumPoolSize = 50;
    /**
     * 线程存活时间 尝试设置为30秒 因为newCachedThreadPool设置为60秒*
     */
    private static int keepAliveTime = 30;
    /**
     * 线程池实例化*
     */
    private static ThreadPoolManager threadPoolManage = new ThreadPoolManager();
    /** **/
    private ThreadPoolExecutor threadPool;
    /**
     * 设置一个有界队列以存放被拒绝的任务 *
     */
    private ArrayBlockingQueue<Runnable> taskQueue = new ArrayBlockingQueue<Runnable>(10000);
    /**
     * 延时执行线程*
     */
    private ScheduledExecutorService appSchedule;

    /**
     * 线程池构造方法
     */
    private ThreadPoolManager() {
        RejectedExecutionHandler myHandler = new RejectedExecutionHandler() {
            public void rejectedExecution(Runnable r,
                                          ThreadPoolExecutor executor) {
                taskQueue.offer(r);
            }
        };
        Runnable command = new

                Runnable() {
                    public void run() {
                        Runnable task = null;
                        try {
                            task = taskQueue.take();//使用具备阻塞特性的方法
                        } catch (InterruptedException e) {
                            return;
                        }
                        threadPool.execute(task);
                    }
                };
        ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(minSchedule);
        scheduledPool.scheduleWithFixedDelay(command, 0L, 1L, TimeUnit.SECONDS);

        //有界队列大小设置为2000
        threadPool = new TimingThreadPool(corePoolSize, maximumPoolSize,
                keepAliveTime, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2000), myHandler);

        appSchedule = Executors.newScheduledThreadPool(minSchedule);
    }

    /**
     * 得到线程池的实例
     *
     * @return
     */
    public static ThreadPoolManager getInstance() {
        return threadPoolManage;
    }

    /**
     * 任务添加到线程池中
     *
     * @param paramRunnable
     */
    public void addExecuteTask(Runnable paramRunnable) {
        if (paramRunnable == null)
            return;
        this.threadPool.execute(paramRunnable);
    }

    /**
     * 延时任务添加到线程池中
     *
     * @param paramRunnable
     */
    public void addDelayExecuteTask(Runnable paramRunnable, int delayTime) {
        appSchedule.schedule(new DelayTask(paramRunnable), delayTime,
                TimeUnit.MILLISECONDS);
    }

    /**
     * 获取线程池的信息
     * taskCount:线程池需要执行的任务数量。
     * completedTaskCount:线程池在运行过程中已完成的任务数量。小于或等于taskCount。
     * largestPoolSize:线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。
     * 如等于线程池的最大大小,则表示线程池曾经满了。
     * poolSize:线程池的线程数量。如果线程池不销毁的话,池里的线程不会自动销毁,所以这个大小只增不减。
     * activeCount:获取活动的线程数。
     *
     * @return
     */
    public String getThreadPoolInfo() {
        StringBuilder sb = new StringBuilder();
        sb.append("taskCount is ").append(threadPool.getTaskCount())
                .append("; completedTaskCount is ").append(threadPool.getCompletedTaskCount())
                .append("; largestPoolSize is ").append(threadPool.getLargestPoolSize())
                .append("; poolSize is ").append(threadPool.getPoolSize())
                .append("; activeCount is ").append(threadPool.getActiveCount());
        return sb.toString();
    }

    private final class TimingThreadPool extends ThreadPoolExecutor {

        private final Logger _log = Logger.getLogger("TimingThreadPool");
        //开始时间放到startTime为键值的ThreadLocalMap当中当中
        private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
        private final AtomicLong numTask = new AtomicLong();
        private final AtomicLong totalTime = new AtomicLong();


        public TimingThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
        }

        @Override
        protected void beforeExecute(Thread t, Runnable r) {
            super.beforeExecute(t, r);
            startTime.set(System.currentTimeMillis());
        }

        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            try {
                long endTime = System.currentTimeMillis();
                long taskTime = endTime - startTime.get();
                _log.info(String.format("TimingThreadPool task cost time is %s", taskTime));
                _log.info(getThreadPoolInfo());
                totalTime.addAndGet(taskTime);
                numTask.incrementAndGet();
            } finally {
                super.afterExecute(r, t);
            }
        }

        @Override
        protected void terminated() {
            try {
                _log.info(String.format("Terminated totalTime is %dms and numTask is %d avg time=%dms", totalTime.get(), numTask.get(), totalTime.get() / numTask.get()));
            } finally {
                super.terminated();
            }
        }
    }

    /**
     * 延时任务*
     */
    class DelayTask implements Runnable {

        private Runnable task;

        public DelayTask(Runnable paramTask) {
            this.task = paramTask;
        }

        public void run() {
            ThreadPoolManager.getInstance().addExecuteTask(task);
        }
    }
}


你可能感兴趣的:(ThreadPoolExecutor的分析与使用)