Android线程之线程池

作者: bamboolmc | 来源:发表于2018-05-24 22:05 被阅读0次

Kotlin系列——在Android中使用协程以及协程源码分析
Android线程之线程池
Android 多线程之线程池
Android 多线程之阻塞队列
Android多线程之常见的线程形态
线程池创建和相关知识
Update AsyncTask And Make New On
Android 多线程之线程池（一）
Android 多线程之线程池（二）
安卓面试笔记

ThreadPoolExecutor(线程池)

构造方法

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

具体参数及其含义

int corePoolSize
核心线程数量，核心线程存在两种状态，与参数设置有关。
存活状态：allowCoreThreadTimeOut 默认设置为false，此设置下，核心线程一直处于存活状态，即使核心线程无任务操作，处于空闲状态。
终止状态： allowCoreThreadTimeOut 设置为true时，超过keepAliveTime设定时常后，核心线程终止，被回收。
int maximumPoolSize
线程池所允许存在的最大线程数量，超过最大线程数后，后续的新任务会被阻塞。
long keepAliveTime
当线程处于空闲状态后，允许存活的时长，超过此时长后，线程会被终止回收。根据allowCoreThreadTimeOut参数不同，限定的线程不同。
限定非核心线程：当allowCoreThreadTimeOut参数值为默认false时，只对非核心线程有限制。
限定核心线程与非核心线程：当allowCoreThreadTimeOut参数值为true时，对线程池中的核心与非核心都由限制，超过限定时长后，线程都会终止并回收。
TimeUnit unit
keepAliveTime的事件单位，TimeUnit类提供枚举，有纳秒、微秒、毫秒等，具体如下。

TimeUnit.NANOSECONDS：纳秒
TimeUnit.MICROSECONDS：微秒
TimeUnit.MILLISECONDS：毫秒
TimeUnit.SECONDS：秒
TimeUnit.MINUTES：分
TimeUnit.HOURS：小时
TimeUnit.DAYS：天

BlockingQueue<Runnable> workQueue
线程池任务队列，阻塞队列，主要用来存储已经提交但尚未分配给线程执行的任务（线程池execute方法提交的Runnable对象）。
ThreadFactory threadFactory
线程工厂，interface类型，只有一个方法Thread newThread(Runnable r); 用来为线程池创建新线程。
RejectedExecutionHandler handler
interface类型，只有一个方法void rejectedExecution(Runnable r, ThreadPoolExecutor executor)，线程池无法执行新任务时，ThreadPoolExecutor调用handler的该方法通知调用者。

调用策略

如果线程池中线程的数量小于核心线程数量，新任务来之后，开启新的核心线程去执行任务。
如果线程池中核心线程数量已经饱和，新任务来之后，则放到workQueue任务队列，代核心线程执行完任务后，从任务队列中取出待处理任务，继续处理。
如果线程池中核心线程数量已经饱和，workQueue任务队列中任务数也达到最大值，再来新任务，则开启一个非核心线程，进行处理任务。之后非核心线程和核心线程一同处理workQueue任务队列中任务。
如果线程池中核心线程数量饱和，workQueue任务队列中任务数也达到最大值，非核心线程也达到最大值，当再来到新任务后，那么线程池就调用RejectedExecutionHandler的rejectedExecution方法拒绝该任务。
特殊情况，如果线程池中无核心线程，并且任务数不大于任务队列限制，则线程池只开启一个非核心线程进行处理。

调用策略示例验证

为了更好的理解调用策略，采用具体的示例，更清晰明了的进行理解。

package com.bamboolmc.threadpro;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPool {
    private static int taskSize = 2;
    private static int corePoolSize = 3;
    private static int maximumPoolSize = 4;
    private static int queueSize = 3;

    public static class TestTask implements Runnable{
        @Override
        public void run() {
            if (taskSize>0){
                try {
                    //模拟任务处理
                    Thread.sleep(500);
                    System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()
                            +" 完成一个任务，编号为t" + (taskSize--));

                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }


    public static void main(String args[]) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                1,
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize));
        TestTask task;
        int size = taskSize;
        for (int i = 0; i < size; i++) {
            task = new TestTask();
            executor.execute(task);
        }
        executor.shutdown();

    }
}

对比调用策略1

    private static int taskSize = 2;
    private static int corePoolSize = 3;
    private static int maximumPoolSize = 4;
    private static int queueSize = 3;

任务数量2，核心线程数量3
运行结果：

1527001137241pool-1-thread-2 完成一个任务，编号为t1
1527001137241pool-1-thread-1 完成一个任务，编号为t2

对比调用策略2

修改如下

    private static int taskSize = 5;
    private static int corePoolSize = 3;
    private static int maximumPoolSize = 4;
    private static int queueSize = 3;

任务数量5，核心线程数量3，任务队列3
运行结果：

1527001567366pool-1-thread-2 完成一个任务，编号为t4
1527001567366pool-1-thread-1 完成一个任务，编号为t5
1527001567366pool-1-thread-3 完成一个任务，编号为t3
1527001567869pool-1-thread-1 完成一个任务，编号为t1
1527001567869pool-1-thread-2 完成一个任务，编号为t2

对比调用策略3

修改如下

    private static int taskSize = 7;
    private static int corePoolSize = 3;
    private static int maximumPoolSize = 4;
    private static int queueSize = 3;

任务数量7, 核心线程数量3,任务队列3，非核心线程1
运行结果：

1527002003014pool-1-thread-3 完成一个任务，编号为t6
1527002003014pool-1-thread-2 完成一个任务，编号为t4
1527002003014pool-1-thread-1 完成一个任务，编号为t7
1527002003014pool-1-thread-4 完成一个任务，编号为t5
1527002003516pool-1-thread-3 完成一个任务，编号为t3
1527002003516pool-1-thread-1 完成一个任务，编号为t2
1527002003516pool-1-thread-2 完成一个任务，编号为t1

对比调用策略4

修改如下

    private static int taskSize = 8;
    private static int corePoolSize = 3;
    private static int maximumPoolSize = 4;
    private static int queueSize = 3;

任务数量8, 核心线程数量3,任务队列3，非核心线程1
运行结果：
第8个任务运行时，线程池拒绝，抛出异常

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.bamboolmc.threadpro.ThreadPool$TestTask@14ae5a5 rejected from java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at com.bamboolmc.threadpro.ThreadPool.main(ThreadPool.java:46)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
1527002190243pool-1-thread-3 完成一个任务，编号为t8
1527002190243pool-1-thread-1 完成一个任务，编号为t6
1527002190243pool-1-thread-2 完成一个任务，编号为t5
1527002190243pool-1-thread-4 完成一个任务，编号为t7
1527002190749pool-1-thread-2 完成一个任务，编号为t3
1527002190749pool-1-thread-1 完成一个任务，编号为t3
1527002190749pool-1-thread-3 完成一个任务，编号为t4

对比调用策略5

修改如下

    private static int taskSize = 3;
    private static int corePoolSize = 0;
    private static int maximumPoolSize = 4;
    private static int queueSize = 3;

任务数量3, 核心线程数量0,任务队列3，非核心线程4
运行结果：

1527002486575pool-1-thread-1 完成一个任务，编号为t3
1527002487078pool-1-thread-1 完成一个任务，编号为t2
1527002487579pool-1-thread-1 完成一个任务，编号为t1

线程池分类

根据构建线程池时传入的参数不同，我们在Android系统中常见有4种不同功能特性的线程池。

CachedThreadPool
FixedThreadPool
SingleThreadExecutor
ScheduledThreadPool

我们可以用Executors.newXXX的方式去实例化我们需要的线程池，如实例化一个CachedThreadPool

 ExecutorService executorService =  Executors.newCachedThreadPool();

CachedThreadPool

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

核心线程数：0
最大线程数：2的31次方－1
超时时长：60秒
任务队列：SynchronousQueue
由此可见，CachedThreadPool只有非核心线程，并且非核心线程最大数量可以任意大，当前已建线程都在执行任务时，再来新的任务会开启新的线程来执行，闲置线程超过60秒，就会被收回。由于使用了SynchronousQueue队列，所有提交的任务都会被立即执行。这类线程池比较适合大量的耗时较少的任务。

FixedThreadPool

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

核心线程数：固定(新建线程池时提供的参数)
最大线程数：同核心线程数
超时时长：0
任务队列：LinkedBlockingQueue
由此可见，FixedThreadPool只有固定个数的核心线程数，无非核心线程，并且核心线程无超时限制，除非线程池关闭，否则线程即使处于空闲状态，也不会被回收，因此能够更快的响应外界请求。另外任务队列容量没有大小限制。当所有线程均有任务执行时，新任务会在任务队列排队，线程执行完，取出任务队列中任务执行。

SingleThreadExecutor

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

核心线程数：1
最大线程数：1
超时时长：0
任务队列：LinkedBlockingQueue
由此可见，SingleThreadExecutor只有1个核心线程，所有任务都会在一个线程中按顺序执行；任务队列容量没有大小限制；另外如果某些错误而导致线程终止，则会创建新的线程继续执行后续的任务（与newFixedThreadPool(1)的不同，无法创建新的线程继续执行后续任务）；由于是在一个线程执行任务，所以无需处理线程同步问题了。

ScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

核心线程数：固定
最大线程数：2的31次方－1
超时时长：10毫秒
任务队列：DelayedWorkQueue
由此可见，ScheduledThreadPool核心线程数固定，非核心线程数无限大，非核心线程超时时长10毫秒。主要用于执行定时任务和具有固定周期的任务。

使用方法异同

ExecutorService executor =  Executors.newCachedThreadPool();
executor.execute(new TestTask());
ExecutorService executor =  Executors.newFixedThreadPool(2);
executor.execute(new TestTask());
ExecutorService executor =  Executors.newSingleThreadExecutor();
executor.execute(new TestTask());

ScheduledExecutorService executor =  Executors.newScheduledThreadPool(2);
 executor.schedule(new TestTask(),2000,TimeUnit.MILLISECONDS);

任务队列BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。

支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满时，自动唤醒被阻塞线程继续执行插入操作。
支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会阻塞，等待队列变为非空时，自动唤醒。

四种类型线程池分析时，发现其中的任务队列参数分别使用到SynchronousQueue、LinkedBlockingQueue、DelayedWorkQueue这三种不同的任务队列。除此之外，系统还提供了PriorityBlockingQueue、ArrayBlockingQueue，DelayQueue，这些类均实现自BlockingQueue接口。

public interface BlockingQueue<E> extends Queue<E> {
    boolean add(E e);
    boolean offer(E e);
    void put(E e) throws InterruptedException;
    boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
    E take() throws InterruptedException;
    E poll(long timeout, TimeUnit unit) throws InterruptedException;
    int remainingCapacity();
    boolean remove(Object o);
    public boolean contains(Object o);
    int drainTo(Collection<? super E> c);
    int drainTo(Collection<? super E> c, int maxElements);
}

BlockingQueue作为一个接口，提供了添加、删除元素方法。

添加方法

add: 添加元素到队列，成功返回true；队列容量满了，再添加元素时，会抛出IllegalStateException异常。
offer：添加元素到队列，成功返回true，失败返回false
put：添加指定元素到队列，如果队列容量满了，则会阻塞到队列有空间。

删除方法

take：删除队列头部元素，如果队列为空，则一直阻塞到队列有元素为止。返回头部元素。
poll：删除队列头部元素，在指定时间内，如果队列不为空，则删除头部元素，并返回头部元素。在制定时间内队列仍为空，则返回null。
remove：删除队列内指定的元素，如果删除成功则返回true，如果找不到该指定元素，抛出NullPointerException。

其他方法

remainingCapacity：返回队列能够添加元素的数量（阻塞或无限制除外）。
contains：队列是否包含某指定元素。
drainTo：从队列中移除（所有或指定数量的）可用元素，并将它们添加到给定集合中。

SynchronousQueue

没有元素存储空间的阻塞队列，如果在插入元素时后续没有执行取出的操作，那么插入的行为就会被阻塞。构造方法如下

public SynchronousQueue()
public SynchronousQueue(boolean fair)

LinkedBlockingQueue

基于链表的阻塞队列，可指定容量，默认容量无穷大（2的31次方－1），采用FIFO（first-in-first-out）的访问策略。

public LinkedBlockingQueue()
public LinkedBlockingQueue(int capacity)
public LinkedBlockingQueue(Collection<? extends E> c)

PriorityBlockingQueue

基于优先级的阻塞队列，队列容量由使用者指定，优先级的高低是如何指定的呢，可根据如下的构造函数中看到Comparator<? super E> comparator 就是指定优先级的比较器。因此队列元素（也就是要执行的任务）需要实现Comparator接口，来定义优先级高低。如果不设置容量大小的话，默认队列容量为11。

public PriorityBlockingQueue()
public PriorityBlockingQueue(int initialCapacity)
public PriorityBlockingQueue(int initialCapacity,Comparator<? super E> comparator)
public PriorityBlockingQueue(Collection<? extends E> c)

ArrayBlockingQueue

基于数组的阻塞队列，队列容量由使用者指定，由于队列基于数组，初始化后，容量大小就是固定的。当设定boolean fair为true时，队列访问策略为FIFO；如果不设定，则默认false，访问策略是无序的。

public ArrayBlockingQueue(int capacity)
public ArrayBlockingQueue(int capacity, boolean fair)
public ArrayBlockingQueue(int capacity, boolean fair,Collection<? extends E> c)

其他

详细的阻塞队列可参考源码及如下文章学习
https://blog.csdn.net/qq_38989725/article/details/73298856

Kotlin系列——在Android中使用协程以及协程源码分析
作者：谭嘉俊 1、概述本篇文章讲解的内容是在Android中使用协程。在说协程之前，我先说下线程和线程池：线...
Android线程之线程池
ThreadPoolExecutor(线程池) 构造方法具体参数及其含义 int corePoolSize核心线...
Android 多线程之线程池
Android 多线程系列 Android 多线程之几个基本问题 Android 多线程之阻塞队列 Android...
Android 多线程之阻塞队列
Android 多线程系列 Android 多线程之几个基本问题 Android多线程之常见的线程形态阻塞队列 ...
Android多线程之常见的线程形态
Android 多线程系列 Android 多线程之几个基本问题 Android 多线程之阻塞队列 Andorid...
线程池创建和相关知识
线程池创建(单例):Android线程池得要这么用 - 简书线程池相关知识:Android开发之线程池使用总结 ...
Update AsyncTask And Make New On
关于android并发 AsyncTask在android2.3的时候线程池是一个核心数为5线程，队列可容纳10线...
Android 多线程之线程池（一）
一为何使用线程池在我们日常的Android开发中，经常使用多线程来处理异步的任务，第一想到的就是new Thr...
Android 多线程之线程池（二）
一线程池中的一些重要概念 Worker / workers Worker类是ThreadPoolExecutor...
安卓面试笔记
OKhttp线程池策略，线程池丢弃策略，jsbridge原理与native交互过程，okhttp源码，子线程之间通...

Android线程之线程池

构造方法

调用策略

调用策略示例验证

对比调用策略1

对比调用策略2

对比调用策略3

对比调用策略4

对比调用策略5

线程池分类

CachedThreadPool

FixedThreadPool

SingleThreadExecutor

ScheduledThreadPool

使用方法异同

任务队列BlockingQueue

SynchronousQueue

LinkedBlockingQueue

PriorityBlockingQueue

ArrayBlockingQueue

其他

相关文章

Kotlin系列——在Android中使用协程以及协程源码分析

Android线程之线程池

Android 多线程之线程池

Android 多线程之阻塞队列

Android多线程之常见的线程形态

线程池创建和相关知识

Update AsyncTask And Make New On

Android 多线程之线程池（一）

Android 多线程之线程池（二）

安卓面试笔记

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读