JDK线程池

线程池状态

image.png

  • RUNNING:线程池初始化时的状态,此时可接受新的任务,也能处理任务队列中的任务。
  • SHUTDOWN:调用shutdown方法后进入该状态,此时不再接受新的任务,但还会处理完任务队列中剩余的任务。
  • STOP:调用shutdownNow方法后进入该状态,此时不再接受新的任务,也不会处理任务队列中剩余的任务。
  • TIDYING:此时所有任务都已终止,workerCount为零,线程池进入该状态后将运行terminate方法并进入TIDYING状态。
  • TERMINATED:terminated方法执行完毕后进入该状态。
    //线程池的状态
    private static final int RUNNING    = -1 << COUNT_BITS;     //高三位111
    private static final int SHUTDOWN   =  0 << COUNT_BITS;     //高三位000
    private static final int STOP       =  1 << COUNT_BITS;     //高三位001
    private static final int TIDYING    =  2 << COUNT_BITS;     //高三位010
    private static final int TERMINATED =  3 << COUNT_BITS;     //高三位011

ThreadPoolExecutor构造函数

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
  • corePoolSize:线程池里面保持运行的线程数 , 默认情况下,线程池是空的,当有任务提交时才会创建线程,如果当前 线程数量小于corePoolSize,则创建核心线程,核心线程会在线程池中一直存活,即使它们处于闲置状态,除非设置了 allowCoreThreadTimeOut.
  • maximumPoolSize:线程池允许的最大的线程数,当前poolSize达到core pool size的时候, 新任务来但是队列满了, 就要看maximumPoolSize了, 如果此时poolSize
  • keepAliveTime:当前线程数大于core时, 闲置的线程最大的等待新任务来到的时间 , 超过时间后闲置线程会被关闭
  • unit:keepAliveTime的单位, TimeUnit有定义
  • BlockingQueue:任务(Runnable任务 ,执行execute提交的任务)执行前会放在工作队列当中
  • ThreadFactory:默认是使用DefaultThreadFactory创建线程
  • RejectedExecutionHandler:当任务 Executor. execute无法受理,例如队列满了等情况则执行拒绝策略,默认使用AbortPolicy.

    • CallerRunsPolicy:提交任务的线程执行提交的任务
    • AbortPolicy:中止执行且抛出异常
    • DiscardPolicy:不处理该任务
    • DiscardOldestPolicy:抛弃最老的任务再次提交当前任务

阻塞队列

  • SynchronousQueue:这个队列接收到任务的时候,会直接提交给线程处理,当所有线程都在工作时,为了保证线程数<= maximumPoolSize,使用这个类型队列的时候,maximumPoolSize一般指定成Integer.MAX_VALUE
  • LinkedBlockingQueue:这个队列接收到任务的时候,如果当前线程数小于核心线程数,则新建线程(核心线程)处理任务;如果当前线程数等于核心线程数,则进入队列等待。由于这个队列没有最大值限制,即所有超过核心 线程数的任务都将被添加到队列中,这也就导致了maximumPoolSize的设定失效,因为总线程数永远不会超过 corePoolSize
  • ArrayBlockingQueue:可以限定队列的长度,接收到任务的时候,如果没有达到corePoolSize的值,则新建线程(核心线程)执行任务,如果达到了,则入队等候,如果队列已满,则新建线程(非核心线程)执行任务,又如果总线程数到了maximumPoolSize,并且队列也满了,则执行拒绝策略
  • DelayQueue:队列内元素必须实现Delayed接口,这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时,首先先入队,只有达到了指定的延时时间,才会执行任务

Executors

image.png

CachedThreadPool

特点:

1.没有核心线程,全是非核心线程,最大线程数为Integer.MAX_VALUE,线程数量依赖于JVM能够创建的最大线程
2.当线程池中的线程都处于活动状态的时候,线程池会创建新的线程来处理新任务,否则会用空闲的线程来处理新任务
3.空闲线程具有超时机制的,keepAliveTime时长为60秒,超过60秒的空闲线程就会被回收,可减少占用系统资源
4.任务队列采用的是SynchronousQueue,这个队列是无法插入任务的,一有任务立即执行
5.CachedThreadPool比较适合任务量大但耗时少的任务
    // 使用默认线程工厂
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

     
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }

FixedThreadPool

特点:

1.全是核心线程,没有非核心线程
2.采用了无界的阻塞队列LinkedBlockingQueue,任务数量无限制
3.keepAliveTime为0,即使是空闲状态,线程不会被回收,除非线程池被关闭
4.适用于任务量比较固定但耗时长的任务
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

ScheduledThreadPool

特点:

1.核心线程数固定,非核心线程数无限制,空闲非核心线程被回收
2.任务队列采用的DelayedWorkQueue是个无界的队列,延时执行队列任务
3.适用于执行定时任务和具体固定周期的重复任务
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    
    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

ScheduledThreadPoolExecutor继承ThreadPoolExecutor,其构造函数

    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

SingleThreadExecutor

1.只有1个核心线程
2.任务队列是LinkedBlockingQueue,无界的阻塞队列
3.确保所有的任务都在同一个线程中顺序执行,这样就不需要处理线程同步的问题
4.适用于多个任务顺序执行的场景
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

评论

暂无评论