精华内容
下载资源
问答
  • ThreadPoolExecutor

    2020-06-13 15:18:00
    ThreadPoolExecutor继承关系结构 ThreadPoolExecutor初始化构造方法 public ThreadPoolExecutor(int corePoolSize, #核心线程池大小,包括空闲线程。 int maximumPoolSize, #线程池最大线程数 long ...

    ThreadPoolExecutor继承关系结构

    ThreadPoolExecutor初始化构造方法

    public ThreadPoolExecutor(int corePoolSize,    #核心线程池大小,包括空闲线程。
                            int maximumPoolSize,   #线程池最大线程数
                              long keepAliveTime,  #超过corePoolSize的空闲线程保持存活的时长
                              TimeUnit unit,       #keepAliveTime时长单位
                              BlockingQueue<Runnable> workQueue    #存放待处理线程的Queue
                              ThreadFactory threadFactory,         #线程工厂对象,定制化线程池的线程属性(name,uncaughtException(),daemon,priority)
                              RejectedExecutionHandler handler)    #异常拒绝处理器,处理任务被拒绝执行时的行为;默认new AbortPolicy()

     ThreadPoolExecutor方法

    int getCorePoolSize()        #返回核心线程数量
    int getMaximumPoolSize()     #返回最大的线程数量
    int getPoolSize()            #返回当前线程池中的线程数量,包括在运行或休眠,new ThreadPoolExecutor()不会立马创建可用线程
    int getQueue().size()        #返回等待执行线程的队列数量
    void shutdown()              #不再添加新task,使当前未执行完的线程继续执行,不会阻塞主线程main,调用shutdown()后,主线程马上结束,而线程池继续执行直到任务执行完毕;shutdown()使线程池状态立即变成SHUTDOWN状态
    List<Runnable> shutdownNow() #中断所有Task并且抛出InterruptesException异常,前提是线程中使用Thread.currentThread().isInterrupted()判断当前线程是否被中断;shutdownNow()使线程池状态立即变成STOP状态,并试图停止所有正在执行的线程,线程池继续执行直到当前任务执行完毕
    boolean isShutdown()         #当前线程池是否已被关闭
    boolean isTerminating()      #判断当前线程池在shutdown()或shutdownNow()后处于正在中止但是尚未完全中止时,返回ture。
    boolean isTerminated()       #判断当前线程池在shutdown()或shutdownNow()后已完全中止时,返回ture。
    boolean awaitTermination(long timeout, TimeUnit unit)  #在指定时间内查看线程池是否已终止工作;在线程池执行shutdown()后,如果池中还有任务在被执行则阻塞,否则将不再阻塞;与shutdown()结合可实现"等待执行完毕"的效果。
    boolean allowsCoreThreadTimeOut()                 #配置核心线程是否有超时效果
    boolean allowsCoreThreadTimeOut(boolean value)    #配置核心线程是否有超时效果
    boolean prestartCoreThread()    #每次初始化一个核心线程,直到达到corePoolSize时返回false
    int prestartAllCoreThreads()    #初始化全部corePoolSize数量的核心线程,返回初始化的个数
    long getCompletedTaskCount()    #返回已执行完成的线程大概累积数量
    void beforeExecute(Thread t, Runnable r)     #线程执行前的操作
    void afterExecute(Runnable r, Throwable t)   #线程执行结束后的操作
    boolean remove(Runnable task)   #删除被execute()调用的尚未被执行的Runnable任务,对submit()调用的线程需使用purge()
    int getActiveCount()            #获取正在执行任务的线程数
    long getTaskCount()             #获取可被执行的任务数
    

    常见3种队列

    作用:作为线程池的缓冲,当新增线程超过maximumPoolSize时,会将新增线程暂时存放到该队列中;

    LinkedBlockingDeque:无边界双端队列;

    1>默认构造器由于该队列大小没有限制,执行execute不会抛出异常,但是线程池同时运行线程数不会超过corePoolSize;此时maximumPoolSize和keepAliveTime无效,因为多于的线程会被放入LinkedBlockingQueue队列中等待;

    2>指定边界大小时,maximumPoolSize+边界大小<待执行的任务时,多于的任务将执行拒绝策略;

    ArrayBlockingQueue:有边界队列;maximumPoolSize+边界大小<待执行的任务时,多余的任务将执行拒绝策略;

    SynchronousQueue:有序队列;当执行的线程大于maximumPoolSize时,多余线程将执行拒绝策略。

     

    4种拒绝策略

    AbortPolicy:当任务添加到线程池被拒绝时,抛出RejectedExceutionExcetion异常,默认策略;

    CallerRunsPolicy:当任务添加到线程池被拒绝时,会调用创建线程池的父线程来处理被拒绝任务;

    DiscardOldestPolicy:当任务添加到线程池被拒绝时,线程池会丢弃等待队列中最旧未处理任务,然后将被拒绝任务添加到等待队列中;

    DiscardPolicy:当任务添加到线程池被拒绝时,线程池会丢弃被拒绝任务;

    展开全文
  • ThreadPoolExecutor

    千次阅读 2010-06-22 15:43:00
    ThreadPoolExecutor

    转自http://www.evget.com/zh-CN/info/catalog/9781.html

    从 Java 5 开始,Java 提供了自己的线程池。线程池就是一个线程的容器,每次只执行额定数量的线程。 java.util.concurrent.ThreadPoolExecutor 就是这样的线程池。它很灵活,但使用起来也比较复杂,本文就对其做一个介绍。

      首先是构造函数。以最简单的构造函数为例:

    public ThreadPoolExecutor(    

    int corePoolSize,    

    int maximumPoolSize,    

    long keepAliveTime,    

    TimeUnit unit,    

    BlockingQueue<Runnable> workQueue)  

      看起来挺复杂的。这里介绍一下。

      corePoolSize 指的是保留的线程池大小。

      maximumPoolSize 指的是线程池的最大大小。

      keepAliveTime 指的是空闲线程结束的超时时间。

      unit 是一个枚举,表示 keepAliveTime 的单位。

      workQueue 表示存放任务的队列。

      我们可以从线程池的工作过程中了解这些参数的意义。线程池的工作过程如下:

      1、线程池刚创建时,里面没有一个线程。任务队列是作为参数传进来的。不过,就算队列里面有任务,线程池也不会马上执行它们。

      2、当调用 execute() 方法添加一个任务时,线程池会做如下判断:

       a. 如果正在运行的线程数量小于 corePoolSize,那么马上创建线程运行这个任务;

       b. 如果正在运行的线程数量大于或等于 corePoolSize,那么将这个任务放入队列。

       c. 如果这时候队列满了,而且正在运行的线程数量小于 maximumPoolSize,那么还是要创建线程运行这个任务;

       d. 如果队列满了,而且正在运行的线程数量大于或等于 maximumPoolSize,那么线程池会抛出异常,告诉调用者“我不能再接受任务了”。

      3、当一个线程完成任务时,它会从队列中取下一个任务来执行。

     4、当一个线程无事可做,超过一定的时间(keepAliveTime)时,线程池会判断,如果当前运行的线程数大于 corePoolSize,那么这个线程就被停掉。所以线程池的所有任务完成后,它最终会收缩到 corePoolSize 的大小。

       这样的过程说明,并不是先加入任务就一定会先执行。假设队列大小为 10,corePoolSize 为 3,maximumPoolSize 为 6,那么当加入 20 个任务时,执行的顺序就是这样的:首先执行任务 1、2、3,然后任务 4~13 被放入队列。这时候队列满了,任务 14、15、16 会被马上执行,而任务 17~20 则会抛出异常。最终顺序是:1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。下面是一个线程池使用的例子:

    public static void main(String[] args) {    

    BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();    

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);    



    for (int i = 0; i < 20; i++) {    

    executor.execute(new Runnable() {    



    public void run() {    

    try {    

    Thread.sleep(1000);    

    } catch (InterruptedException e) {    

    e.printStackTrace();    

    }    

    System.out.println(String.format("thread %d finished", this.hashCode()));    

    }    

    });    

    }    

    executor.shutdown();    

    }  

     

      对这个例子的说明如下:

       1、BlockingQueue 只是一个接口,常用的实现类有 LinkedBlockingQueue 和 ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大小限制。这样的话,因为队列不会满,所以 execute() 不会抛出异常,而线程池中运行的线程数也永远不会超过 corePoolSize 个,keepAliveTime 参数也就没有意义了。

      2、shutdown() 方法不会阻塞。调用 shutdown() 方法之后,主线程就马上结束了,而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法,那么线程池会一直保持下去,以便随时添加新的任务。

      到这里对于这个线程池还只是介绍了一小部分。ThreadPoolExecutor 具有很强的可扩展性,不过扩展它的前提是要熟悉它的工作方式。后面的文章将会介绍如何扩展 ThreadPoolExecutor 类。

      java.util.concurrent.ThreadPoolExecutor 类提供了丰富的可扩展性。你可以通过创建它的子类来自定义它的行为。例如,我希望当每个任务结束之后打印一条消息,但我又无法修改任务对象,那么我可以这样写:

      除了 afterExecute 方法之外,ThreadPoolExecutor 类还有 beforeExecute() 和 terminated() 方法可以重写,分别是在任务执行之前和整个线程池停止之后执行。

       除了可以添加任务执行前后的动作之外, ThreadPoolExecutor 还允许你自定义当添加任务失败后的执行策略。你可以调用线程池的 setRejectedExecutionHandler() 方法,用自定义的 RejectedExecutionHandler 对象替换现有的策略。 ThreadPoolExecutor 提供 4 个现有的策略,分别是:

      ThreadPoolExecutor.AbortPolicy:表示拒绝任务并抛出异常

      ThreadPoolExecutor.DiscardPolicy:表示拒绝任务但不做任何动作

      ThreadPoolExecutor.CallerRunsPolicy:表示拒绝任务,并在调用者的线程中直接执行该任务

      ThreadPoolExecutor.DiscardOldestPolicy:表示先丢弃任务队列中的第一个任务,然后把这个任务加进队列。

      这里是一个例子:

    ThreadPoolExecutor executor = new ThreadPoolExecutor(size, maxSize, 1, TimeUnit.DAYS, queue);

    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

      除此之外,你也可以通过实现 RejectedExecutionHandler 接口来编写自己的策略。下面是一个例子:

     

    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.SECONDS, queue,
    new RejectedExecutionHandler() {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    System.out.println(String.format("Task %d rejected.", r.hashCode()));
    }
    }



    );

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,399
精华内容 12,159
关键字:

threadpoolexecutor