码迷,mamicode.com
首页 > 编程语言 > 详细

线程池的参数

时间:2020-07-11 23:03:36      阅读:67      评论:0      收藏:0      [点我收藏+]

标签:read   cap   trie   man   from   public   maximum   number   nan   

这个东西都已经烂大街了啊,但是我还是想写一下。其实很简单,直接看源码就行。

打开ThreadPoolExecutor.java,搜索他的构造方法,一共看到4个。我们直接看参数最多的一个

/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
* parameters.
*
* @param corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @param maximumPoolSize the maximum number of threads to allow in the
* pool
* @param 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.
* @param unit the time unit for the {@code keepAliveTime} argument
* @param workQueue the queue to use for holding tasks before they are
* executed. This queue will hold only the {@code Runnable}
* tasks submitted by the {@code execute} method.
* @param threadFactory the factory to use when the executor
* creates a new thread
* @param handler the handler to use when execution is blocked
* because the thread bounds and queue capacities are reached
* @throws IllegalArgumentException if one of the following holds:<br>
* {@code corePoolSize < 0}<br>
* {@code keepAliveTime < 0}<br>
* {@code maximumPoolSize <= 0}<br>
* {@code maximumPoolSize < corePoolSize}
* @throws NullPointerException if {@code workQueue}
* or {@code threadFactory} or {@code handler} is null
*/
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}

其实注释已经写的很清楚了,

corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
核心线程数:这个线程数会一直存活在池子中,即使他们全部都是空闲的,除非你设置了allowCoreThreadTimeOut参数
maximumPoolSize the maximum number of threads to allow in the
* pool
最大线程数,线程池里面最多允许这个数量的线程同时运行,就是不能超过这个数量。
 * @param 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.
* @param unit the time unit for the {@code keepAliveTime} argument
这个就是,当池子里的线程数超过了核心线程数的值,那些额外的线程在没有任务时能够存活的最长时间和单位。

 * @param workQueue the queue to use for holding tasks before they are
* executed. This queue will hold only the {@code Runnable}
* tasks submitted by the {@code execute} method.
这个就是,当工作异常繁忙时,核心线程数占满了,最大线程数也占满了,这时候还有任务怎么办,放到定义的队列上,这个队列你可以放ArrayBlockingQueue或者LinkedBlockingQueue。
* @param threadFactory the factory to use when the executor
* creates a new thread
这个就是,我核心线程数满了,我要新建线程来执行工作,线程怎么创建呢?通过你定义的这个工厂来创建。默认的有Executors里面的DefaultThreadFactory,其实就是定义一个名字等相关的东西,当然也可以重写,一般在框架中重写的还是比较多的。
* @param handler the handler to use when execution is blocked
* because the thread bounds and queue capacities are reached

最后一个就是线程的拒绝策略啦,这个也比较大街了,其实就是等待队列都放不下的时候怎么办呢?提供了四种,我贴一下源码吧,也比较简单
 /**
     * A handler for rejected tasks that runs the rejected task
     * directly in the calling thread of the {@code execute} method,
     * unless the executor has been shut down, in which case the task
     * is discarded.
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller‘s thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

    /**
     * A handler for rejected tasks that throws a
     * {@code RejectedExecutionException}.
     */
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

    /**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

/**
* A handler for rejected tasks that discards the oldest unhandled
* request and then retries {@code execute}, unless the executor
* is shut down, in which case the task is discarded.
*/
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardOldestPolicy} for the given executor.
*/
public DiscardOldestPolicy() { }

/**
* Obtains and ignores the next task that the executor
* would otherwise execute, if one is immediately available,
* and then retries execution of task r, unless the executor
* is shut down, in which case task r is instead discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
 
CallerRunsPolicy :满了,你提交你自己执行去吧,我没空。
AbortPolicy :满了,我忙不过来,我扔了,给你报个异常吧
DiscardPolicy :满了,我忙不过来,反正也不重要,给你扔了得了。就当没这个活儿。
DiscardOldestPolicy :满了,找找队列上最早的吧,最早的还没干完,估计客人都走了,还没干完,别干了,把最早的去掉吧,新来的加到队列上。

总的来说,李叔的注释没有看不懂的,具体要用哪种结合具体业务去看。






线程池的参数

标签:read   cap   trie   man   from   public   maximum   number   nan   

原文地址:https://www.cnblogs.com/yidiandhappy/p/13285787.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!