线程池ThreadPool工作中的再次思考

ThreadPoolExecutor类实现了ExecutorService接口和Executor接口，可以设置线程池corePoolSize，最大线程池大小maximumPoolSize，拒绝策略。构造方法：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, 
TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler)

参数含义：

corePoolSize：线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最大数量
unit：线程池维护线程所允许的空闲时间的单位
workQueue：线程池所使用的缓冲队列
handler：线程池对拒绝任务的处理策略

当一个任务通过execute(Runnable)方法欲添加到线程池时：
l 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
2 如果此时线程池中的数量大于等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
3 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
4 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

需要注意的是：如果缓冲队列workQueue是采用无界的话，那么maximumPoolSize的设置将无意义。当线程池中的数量大于等于 corePoolSize新的任务会一直添加到缓存队列中。

workQueue常用的是：ArrayBlockingQueue LinkedBlockingQueue等。

常用的拒绝策略：
AbortPolicy
为java线程池默认的阻塞策略，不执行此任务，而且直接抛出一个运行时异常，切记ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。
DiscardPolicy
直接抛弃，任务不执行，空方法
DiscardOldestPolicy
从队列里面抛弃head的一个任务，并再次execute 此task。
CallerRunsPolicy
该策略直接在调用者线程中运行当前被拒绝的任务，但是，调用者线程性能可能急剧下降。

最近在工作中接触到一个比较暴力的线程拒绝策略，引发了比较大的问题，当并发多时，时常导致服务器down掉。
我将工作中的用到的线程池简化为如下：

/**
 * 
 * @author kxl
 *
 */
package test;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class WorkThreadPool {

    private final static int corePoolSize = 2;
    private final static int maximumPoolSize = 4;
    private final static int keepAliveTime =3;
    private final static long waitTime =5;

    private static ThreadPoolExecutor workers;

    public static void init() {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(1);//有界 队列长度1
        RejectedExecutionHandler handler = new RejectedExecutionHandler() {
            public void rejectedExecution(Runnable r,
                    ThreadPoolExecutor executor) {
                try {
                    Thread.sleep(WorkThreadPool.waitTime);
                } catch (InterruptedException e) {
                }

                executor.execute(r);
            }
        };

        if (workers == null) {
            workers = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
                    keepAliveTime, TimeUnit.SECONDS, workQueue,handler);
            workers.allowCoreThreadTimeOut(true);
        }
    }

    public synchronized static void addTask(Integer  task) {
        if (workers == null)
            init();
        workers.execute(new WorkThread(task));
        //System.out.println("worder size=="+workers.getPoolSize());
    }

    public synchronized static boolean removeTask(Integer publishQueue) {
        if (workers == null)
            return false;
        for (Runnable runnable : workers.getQueue()) {
            WorkThread pubThread = (WorkThread) runnable;

            if (publishQueue != null
                    && publishQueue.equals(pubThread.getTask())) {
                return workers.remove(runnable);
            }
        }
        return false;
    }
    public static void main(String[] args) {
        for(int i=0;i<200;i++){
             WorkThreadPool.addTask(i);
        }
    }


}

class WorkThread implements Runnable {
    public int task;
    public WorkThread(int i){

        this.task=i;
    }

    public int getTask() {
        return task;
    }


    public void setTask(int task) {
        this.task = task;
    }


    public void run() {

        System.out.println(Thread.currentThread().getName() + " is running task"+task);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

上面构建了一个corePoolSize为2 最大线程为4，且缓存队列长度为1。来测试一下改拒绝策略。

这里写图片描述

由上面的结果可以看到添加新任务线程时，进入拒绝策略，又调用executor.execute(r);可以看该源码，里面又将这个任务继续添加进线程任务中，然后又会被执行到拒绝策略，有疑似死循环的迹象。非常不合理的处理方案。

可以考虑用CallerRunsPolicy策略：

RejectedExecutionHandler handler = new RejectedExecutionHandler() {
            public void rejectedExecution(Runnable r,
                    ThreadPoolExecutor executor) {
                try {
                    Thread.sleep(WorkThreadPool.waitTime);
                } catch (InterruptedException e) {
                }
                //executor.execute(r);
                WorkThread pubThread = (WorkThread) r;
                System.out.println("拒绝策略："+pubThread.getTask());

                //上面注释的方法，大量并发时，一直尝试往已经满了的线程池添加任务，一直重复进入拒绝策略（疑似死循环）
                //主线程去调用  相当于CallerRunsPolicy策略
                if (!executor.isShutdown()) {
                        r.run();
                }

            }
        };
            if (workers == null) {
            workers = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
                    keepAliveTime, TimeUnit.SECONDS, workQueue,handler);
            workers.allowCoreThreadTimeOut(true);
        }

上面的代码相当于

workers = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,keepAliveTime,
 TimeUnit.SECONDS, workQueue,new ThreadPoolExecutor.CallerRunsPolicy());

我为了打印一些输出，用上面的方式，可以看callerRunsPolicy源码，里面就是通过r.run进行调用的。

这里写图片描述

如上图输出，当进入拒绝策略后，会由调用者线程中（在本例中就是main主线程）去执行被拒绝的任务，而不是像上面的方法，再次添加到线程任务中这么粗暴的方案了。

线程池ThreadPool工作中的再次思考

猜你喜欢