Android/java 多线程(五)-ThreadPoolExecutor线程池的使用

多线程系列历史文章:
Android/java 多线程(一)-Thread的使用以及源码分析
Android/java 多线程(二)-Thread的好兄弟Handler
Android/java 多线程(三)-HandlerThread的使用场景及源码解析
Android/java多线程(四)-IntentService

前面几篇文章主要都是介绍的单个线程的运用以及原理,这篇文章开始讲解多个线程的运用

简介

线程池是一个能对多个线程进行统一管理的一套机制,它具有诸多的优点:

  • 能对线程进行复用,当有空闲的线程,线程池会复用这些线程而不会去重新创建,节省了资源
  • 能灵活创建各种线程使用场景,内部封装了常用线程池创建逻辑,并支持自定义线程池逻辑创建
  • 能准确的对每一个线程进行管理,并能读取每个线程的一写基础信息,方便进行一些逻辑处理

缺点:
线程中的数据传递没有Handler机制方便

使用场景:
具有诸多耗时任务的情况,当系统为每一个任务创建一个线程,会占用系统的大量资源,容易引起界面的卡顿,线程池的复用机制就很好的解决了这个问题

常用的线程池的使用

自定义线程池
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue 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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

传入不同的参数,实现的效果也不同,下面说一下每个参数的作用:

  • corePoolSize 核心线程数,,即使空闲时仍保留在池中的线程数,除非设置了allowCoreThreadTimeOut
  • maximumPoolSize 线程池中允许的最大线程数
  • keepAliveTime 顾名思义,线程终止前的存活时间,即当线程数大于核心线程数(corePoolSize )时,多余的空闲线程在终止之前等待新任务的最大时间
  • TimeUnit keepAliveTime的单位
  • workQueue 在执行任务之前用于保存任务的队列。 该队列将仅保存execute方法提交的Runnable任务。
  • ThreadFactory 执行程序创建新线程时使用的工厂
  • RejectedExecutionHandler 执行被阻止时使用的处理程序

这里说一下各个参数的配置套路,当使用execute(Runnable)方法添加一个任务到队列中,如果corePoolSizemaximumPoolSize小,队列满了后就会去创建新的线程,当corePoolSizemaximumPoolSize相等时,就会创建一个固定大小的核心线程池。如果将maximumPoolSize设置为无限大(例如nteger.MAX_VALUE),则是创建一个能容纳任意数量任务的线程池。
ThreadFactory的作用是用来创建新的线程的,它是一个接口,实现它即可创建一个新的线程:

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

通过它,你可以指定线程的名称,优先级,守护进程等,如果不设置,则会默认使用Executors.defaultThreadFactory(),它会创建一个与所有线程与所有相同的ThreadGroup并且具有相同的优先级和非守护进程状态NORM_PRIORITY
workQueue是一个排队策略,一般有三种:

  • 直接切换:对应SynchronousQueue实现类,将任务直接交给线程处理,不需要另外的控制,通常需要配置一个无限制的maximumPoolSizes,以避免拒绝掉新提交的任务
  • 无界队列:对应LinkedBlockingDeque实现类,它没有预定的容量,当有新的任务,会在队列中等待,直到加入到corePoolSize的线程中,如果corePoolSize线程一直很忙,也不会去创建新的线程,此时,最大值最小值对它没有任何的影响,每个任务与其他的任务都是独立的,不会互相影响
  • 有边界的队列:例如ArrayBlockingQueue实现类,它有助于在使用有限的maxPoolSize时防止资源的耗尽,但它更难调整与控制。

一般情况下我们都可以通过java提供的工厂模式来构造我们的线程池策略,主要提供了以下几种方式:

newCachedThreadPool

特点:

  • 线程重用,如果没有重用的线程,将会创建一个新的线程添加到池中
  • 适合执行短期异步任务程序,默认为60秒的线程等待时间,超过就会终止与移除
  • 闲置的线程不会消耗资源

源码配置:

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

使用场景:
它创建了一个无限扩大的线程池,但没有核心线程池,因此资源占用少,适合处理一些短期的异步任务

newFixedThreadPool

特点:

  • 创建一个固定数量的线程池,不能随时的新建线程,如果队列已满,提交了新任务,必须等待一个可用的线程
  • 线程会一直存在,直到调用shutdown方法

源码配置:

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

使用场景:
它创建了一个核心线程数与最大线程数相同的线程池,适用于已知任务数量,对线程数量进行限制的场景

newWorkStealingPool

特点:

  • 创建使用所有给定并行级别的线程池,并且可以使用多个队列来减少占用
    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

使用场景:
它能创建一个拥有多个任务队列的线程池,可以减少链接数。并且它是默认创建当前可用cpu数量的线程来并行执行,因此适用于非常耗时的操作,并且可以并行执行

newSingleThreadExecutor

特点:

  • 有且只有一个任务处于活动状态
  • 先提交的先执行,有任务顺序
  • 当任务出现异常,会另创建一个新的线程替换
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

使用场景:
它是一个单例线程,并且有执行顺序,所以适用于有执行顺序的任务,并且有且只有一个任务是执行中的

ScheduledThreadPoolExecutor

特点:

  • 能设置延迟时间,能定期执行
  • 空闲的线程会保留
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

使用场景:
它具有定时特性,因此可以用来执行周期行的任务

五大线程池介绍完毕,此外还有其他的常用方法:

  • execute(Runnable command) 提交任务,在将来的某个时间点执行任务
  • afterExecute(Runnale r,Throwable t) 在指定的Runnale执行后调用此方法
  • beforeExecute(Thread t,Runnable r)在给定的线程中执行给定的Runnable之前调用方法
  • funalize 当执行器不再被引用并且没有线程时,调用shundown
  • shundown 启动有序关闭,先前提交的任务会执行,执行完毕后关闭
  • shundownNow 主动停止执行中的任务,并返回正在执行等待的任务列表

你可能感兴趣的:(Android/java 多线程(五)-ThreadPoolExecutor线程池的使用)