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

标签: ThreadPool线程池 线程池拒绝策略
13人阅读 评论(0) 收藏 举报
分类:

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主线程)去执行被拒绝的任务,而不是像上面的方法,再次添加到线程任务中这么粗暴的方案了。

查看评论

Python多线程简易版 - 线程池threadpool

http://blog.sina.com.cn/s/blog_631d3a630101jxj2.html 好久没分享技术类文章了,一方面是感觉自己技术差,另一方面是最近静不下心去研究,总是不...
  • oMingZi12345678
  • oMingZi12345678
  • 2016-05-01 20:54:21
  • 1219

python 线程池threadpool(使用篇)

可以使用python语言自己实现线程池,或者可以使用第三方包threadpool线程池包,本主题主要介绍threadpool的使用以及其里面的具体实现。...
  • hehe123456ZXC
  • hehe123456ZXC
  • 2016-08-20 02:44:23
  • 58353

简单使用Boost线程池threadpool

场景: 1.在一些多线程的程序中,比如服务端响应请求时,可以同时响应多个客户端的请求,但是响应请求的个数(即线程)的个数过多的话就会造成系统资源损耗过多而宕机,还比在做一些下载的程序时,可同时开...
  • liujiayu2
  • liujiayu2
  • 2016-03-29 16:43:43
  • 8058

python线程池(threadpool)模块使用python2.7

一、安装与简介 pip install threadpool    pool = ThreadPool(poolsize) requests = makeRequests(some_c...
  • qi1840439776
  • qi1840439776
  • 2017-04-22 18:14:41
  • 4806

python 线程池threadpool之实现

上一节介绍了线程池threadpool的安装和使用,本节将主要介绍线程池工作的主要流程: (1)线程池的创建 (2)任务的创建 (3)任务的推送到线程池 (4)线程处理任务 (5)线程池的退...
  • hehe123456ZXC
  • hehe123456ZXC
  • 2016-08-20 05:24:04
  • 7809

ThreadPool四种线程池

线程池使用对象的概念,目的是减小对象的创建和注销的开支,减轻JVM的压力。 为什么使用线程池呢?因为newTread有很多弊端。 1.新建对象性能差; 2.线程之间缺乏统一管理,可能无限创建线程,相互...
  • baozilichao
  • baozilichao
  • 2016-07-18 19:34:02
  • 8312

线程池ThreadPool详解

http://www.cnblogs.com/kissdodog/archive/2013/03/28/2986026.html 一、CLR线程池   管理线程开销最好的方式: 尽量...
  • zhaoguanghui2012
  • zhaoguanghui2012
  • 2016-10-24 11:23:06
  • 15928

ThreadPool2 线程池

  • 2011年12月06日 00:35
  • 3KB
  • 下载

线程池ThreadPool

  • 2008年03月21日 15:58
  • 14KB
  • 下载

线程组threadgroup、线程池threadpool

基础概念(百科) 在Java中每一个线程都归属于某个线程组管理的一员,例如在主函数main()主工作流程中产生一个线程,则产生的线程属于main这个线程组管理的一员。简单地说,线程组(ThreadG...
  • zhangbuzhangbu
  • zhangbuzhangbu
  • 2015-10-31 22:56:48
  • 2111
    个人资料
    等级:
    访问量: 6万+
    积分: 1454
    排名: 3万+
    最新评论