Android多线程学习：线程池（一）

一、概念

线程池：创建并维护一定数量的空闲线程，当有需要执行的任务，就交付给线程池中的一个线程，任务执行结束后，该线程也不会死亡，而是回到线程池中重新变为空闲状态。

线程池优点：
1、重用线程池中的线程，避免频繁创建和销毁线程所带来的内存开销。
2、有效控制线程的最大并发数，避免因线程之间抢占资源而导致的阻塞现象。
3、能够对线程进行简单的管理，提供定时执行以及指定时间间隔循环执行等功能。

二、线程池使用

ThreadPoolExecutor是线程池的实现，先来个小demo，核心代码如下：

    private void threadPoolTest() {
        //创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4 , 3, TimeUnit.SECONDS, 
                    new LinkedBlockingDeque<>(3), new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 5; i++) {
            String data = "task@" + i;
            Log.i(TAG, data);
             //提交任务
            threadPoolExecutor.execute(new ThreadPoolRunnable(data));
        }
        Log.i(TAG, "start test ---------------");
    }

    class ThreadPoolRunnable implements Runnable {
        private Object taskData;
        public ThreadPoolRunnable(Object taskData) {
            this.taskData = taskData;
        }

        @Override
        public void run() {
            Log.i(TAG, "run - runnableData: " + taskData + " | " + Thread.currentThread());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            taskData = null;
        }
    }

三、线程池创建参数说明

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

corePoolSize (int )：核心线程的个数。线程池中有两类线程，核心线程和非核心线程。核心线程默认情况下会一直存在于线程池中，即使这个核心线程什么都不干（铁饭碗），而非核心线程如果长时间的闲置，就会被销毁（临时工）。如果调用了线程池的prestartAllCoreThreads()或prestartCoreThread()方法，线程池会提前创建并启动所有核心线程。
maximumPoolSize (int )：线程池所能容纳的最大线程数。当活动线程数达到这个数值后，后续的新任务将会被阻塞。该值等于核心线程数量 + 非核心线程数量。如果任务队列使用无界的阻塞队列，该参数没有什么效果。

有界阻塞队列和无界阻塞队列含义和区别：
阻塞队列有一个非常重要的属性：容量的大小，分为有界和无界两种。
无界阻塞队列：队列容量很大，近似无上界，例如 LinkedBlockingQueue 的上限是 Integer.MAX_VALUE，约为 2 的 31 次方，是非常大的一个数，可以近似认为是无限容量。
有界阻塞队列：队列容量有上界，例如 ArrayBlockingQueue 如果容量满了，也不会扩容，所以一旦满了就无法再往里放数据了。

keepAliveTime (long)：非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。如果设置allowCoreThreadTimeOut(true)，则会也作用于核心线程。
unit (TimeUnit )：keepAliveTime的时间单位。
workQueue(BlockingQueue)：线程池中的任务队列，通过线程池的execute方法提交的Runnable对象存储在这个参数中，遵循先进先出原则。
threadFactory(ThreadFactory )：创建线程的工厂，用于批量创建线程，统一在创建线程时设置一些参数，如是否守护线程、线程的优先级等。如果不指定，默认使用Executors.defaultThreadFactory() 来创建线程，线程具有相同的NORM_PRIORITY优先级并且是非守护线程。

private static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

handler(RejectedExecutionHandler )：拒绝处理策略，线程数量大于最大线程数就会采用拒绝处理策略。

四种拒绝处理的策略如下:

ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出RejectedExecutionException异常。

ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列头部（最旧的）的任务，然后重新尝试执行程序（如果再次失败，重复此过程）。

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

使用总结：
demo中的构造代码如下，声明了2个核心进程，最大进程数为4，非核心进程空闲超时时长是3s。阻塞队列使用LinkedBlockingDeque，并指定大小为3，防止队列无限膨胀，拒绝处理策略为DiscardOldestPolicy，丢弃队列头部（最旧的）的任务。

 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4 , 3, TimeUnit.SECONDS, 
                    new LinkedBlockingDeque<>(3), new ThreadPoolExecutor.DiscardOldestPolicy());

四、线程池常用阻塞队列(BlockingQueue)

常用阻塞队列类图.jpg

1、ArrayBlockingQueue（常用）

ArrayBlockingQueue.jpg

基于数组的阻塞队列。ArrayBlockingQueue 内部，维护了一个定长数组，以便缓存队列中的数据对象，这是一个常用的阻塞队列。
ArrayBlockingQueue 在生产者放入数据和消费者获取数据，都是共用同一个锁对象，由此也意味着两者无法真正并行运行，没有实现读写分离。
在创建 ArrayBlockingQueue 时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

ArrayBlockingQueue 使用 ReentrantLock 的公平锁和非公平锁来实现该功能。简单理解就是，ReentrantLock 内部会维护一个有先后顺序的等待队列，假如有五个任务一起过来，都被阻塞了。如果是公平的，则等待队列中等待最久的任务就会先进入阻塞队列。如果是非公平的，那么这五个线程就需要抢锁，谁先抢到，谁就先进入阻塞队列。

2、LinkedBlockingQueue（常用）

LinkedBlockingQueue.jpg

由链表结构组成的有界阻塞队列。LinkedBlockingQueue 不指定队列的大小时，默认值是 Integer.MAX_VALUE 。但是，建议指定一个固定大小。因为，如果生产者的速度比消费者的速度大的多的情况下，这会导致阻塞队列一直膨胀，直到系统内存被耗尽。
LinkedBlockingQueue 实现了读写分离，可以实现数据的读和写互不影响，这在高并发的场景下，对于效率的提高无疑是非常巨大的。

3、SynchronousQueue

SynchronousQueue.jpg

这是一个没有缓冲的无界队列，size为0。当执行插入元素的操作时，必须等待一个取出操作。也就是说，put元素的时候，必须等待 take 操作。
适用于并发任务不大，而且生产者和消费者的速度相差不多的场景下，直接把生产者和消费者对接，不用经过队列的入队出队这一系列操作，效率上会高一些。
Excutors.newCachedThreadPool 方法用的就是这种队列，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

4、PriorityBlockingQueue

PriorityBlockingQueue.jpg

这是一个支持优先级排序的无界队列。
可以指定初始容量大小（注意初始容量并不代表最大容量），或者不指定，默认大小为 11。也可以传入一个比较器，把元素按一定的规则排序，不指定比较器的话，默认是自然顺序。
PriorityBlockingQueue 是基于二叉树最小堆实现的，每当取元素的时候，就会把优先级最高的元素取出来。

5、DelayQueue

一个带有延迟时间的无界阻塞队列，队列中的元素，只有等延时时间到了，才能取出来。此队列一般用于过期数据的删除，或任务调度。

五、线程池常用方法

execute(Runnable run)：提交任务，交由线程池调度；
shutdown()：关闭线程池，等待任务执行完成；
shutdownNow()：关闭线程池，不等待任务执行完成；
getTaskCount()：返回线程池找中所有任务的数量 (已完成的任务+阻塞队列中的任务)；
getCompletedTaskCount()：返回线程池中已执行完成的任务数量 (已完成的任务)；
getPoolSize()：返回线程池中已创建线程数量；
getActiveCount()：返回当前正在运行的线程数量；
terminated()：线程池终止时执行的策略。

六、线程池状态

ThreadPoolExecutor类中使用了一些final int常量变量来表示线程池的状态 :

private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;

1、RUNNING

线程池创建后处于RUNNING状态。
线程池能够接收新任务，也能够对已经添加的任务进行处理。

2、SHUTDOWN

线程池已经被关闭了，不再接收新任务；但是，其还是会处理队列中的剩余的任务。
调用线程池的shutdown()方法后，线程池的状态就会由RUNNING转为SHUTDOWN。

3、STOP：

线程池处于STOP状态，此时线程池不再接收新任务，不处理已经添加进来的任务，并且会中断正在处理的任务。
调用线程池的shutdownNow()方法后，线程池的状态就会由RUNNING或SHUTDOWN转为STOP；

4、TIDYING：

workCount（有效线程数）为0。
线程池被下达关闭命令后，如果当前所有的任务都已经终止了（这个终止可以表示执行结束，也可以表示强制中断，也可以表示被丢弃），那么线程就会进入TIDYING状态；当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时进行相应的处理，可以通过重载terminated()函数来实现。
如果线程状态已经是SHUTDOWN了，并且线程中以及队列中都没有任务时，线程池就会由SHUTDOWN转为TIDYING；如果线程池状态为STOP，那么当线程池把所有的任务都给清理干净时，线程池就会由STOP转为TIDYING。

5、TERMINATED：

线程池就结束了；线程池就不能重新启动了。
如果线程池处于TIDYING状态，那么当线程池执行完terminated()方法后，线程池状态就会由TIDYING转为TERMINTED。

线程池状态转换图.png

七、线程池分类

1、newFixedThreadPool()

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

线程数量固定且都是核心线程：核心线程数量和最大线程数量都是nThreads。
keepAliveTime = 0L，即使线程池中的线程空闲，也不会被回收。除非调用shutDown()或shutDownNow()去关闭线程池。
可以更快响应外界的请求，且任务阻塞队列为无边界队列(LinkedBlockingQueue()链表结构的阻塞队列)，意味着任务可以无限加入线程池。
可控制线程最大并发数。

2、newScheduledThreadPool()

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    //默认闲置超时回收时常
    private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

核心线程数量固定，非核心线程数量无限制。
非核心线程闲置超过10s会被回收。
主要用于执行定时任务和具有固定周期的重复任务。

3、newSingleThreadExecutor()

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

核心线程数为1的线程池。确保所有任务在同一线程执行，因此不用考虑线程同步问题，从命名也可以看出来，其他为ThreadPool线程池，当前类型为ThreadExecutor，执行线程。（相当于newFixedThreadPool传入线程个数是1）。
阻塞队列是无界的，可以一直接收任务。
常用于不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作、文件操作等。

4、newCachedThreadPool()

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

没有核心线程，非核心线程无限，但执行完任务后，空闲超过60s则回收空闲线程。
使用SynchronousQueue() 队列，有新任务时使用空闲线程执行，没有空闲线程则创建新的线程来处理。
适合执行大量的耗时较少的任务，当所有线程闲置超过60s都会被停止，所以这时几乎不占用系统资源。

八、各类线程池使用

基础知识差不多了，可以撸代码了，以下为核心代码：

   public void fixedThreadPoolTest() {
        Log.i(TAG, "----fixedThreadPoolTest----");
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) {
            String data = "task@" + i;
            Log.i(TAG, data);
            fixedThreadPool.execute(new ThreadPoolRunnable(data));
        }
   }

   public void cachedThreadPoolTest() {
        Log.i(TAG, "----cachedThreadPoolTest----");
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            String data = "task@" + i;
            Log.i(TAG, data);
            cachedThreadPool.execute(new ThreadPoolRunnable(data));
        } 
   }

   public void singleThreadExecutorTest() {
        Log.i(TAG, "----singleThreadExecutorTest----");
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            String data = "task@" + i;
            Log.i(TAG, data);
            singleThreadExecutor .execute(new ThreadPoolRunnable(data));
        } 
   }

   public void scheduledThreadPoolTest() {
        Log.i(TAG, "----scheduledThreadPoolTest----");
        //这里创建的是ScheduledExecutorService对象，ScheduledExecutorService是ExecutorService的子类
        mScheduledThreadPool = Executors.newScheduledThreadPool(2);
        for (int i = 0; i < 5; i++) {
            String data = "task@" + i;
            Log.i(TAG, data);
            // 1000ms后执行runnable
            mScheduledThreadPool.schedule(new ThreadPoolRunnable(data), 1000, TimeUnit.MILLISECONDS);
        } 
   }

   public void scheduledAtFixedRateTest() {
        Log.i(TAG, "----scheduledAtFixedRateTest----");
        //这里创建的是ScheduledExecutorService对象，ScheduledExecutorService是ExecutorService的子类
        mScheduledThreadPool = Executors.newScheduledThreadPool(2);
        // 1s后，每2s执行一次runnable
        mScheduledThreadPool.scheduleAtFixedRate(new ThreadPoolRunnable(666), 1000, 2000, TimeUnit.MILLISECONDS);
   }

   public void scheduledCancelTest() {
        Log.i(TAG, "----scheduledCancelTest----");
        if (mScheduledThreadPool != null) {
            mScheduledThreadPool.shutdown();
        }
   }

   class ThreadPoolRunnable implements Runnable {
        private Object taskData;
        public ThreadPoolRunnable(Object taskData) {
            this.taskData = taskData;
        }

        @Override
        public void run() {
            Log.i(TAG, "run - runnableData: " + taskData + " | " + Thread.currentThread());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            taskData = null;
        }
   }

运行结果：

fixedThreadPoolTest.png

cachedThreadPoolTest函数，看下图结果可知，一共新建了5个线程来执行这5个任务，所以newCachedThreadPoo()只适合耗时较短的任务，否则会一直创建新线程。

cachedThreadPool.png

singleThreadExecutorTest.png

scheduledThreadPoolTest.png

scheduleAtFixedRateTest.png

参考文章：
线程池10：线程池的5种状态；
常用阻塞队列 BlockingQueue 有哪些？
Android多线程：理解和简单使用总结
 Android 线程池
 全方位解析-Android中的线程池

最后编辑于：2022.08.09 09:24:55

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 216,287评论 6赞 498
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,346评论 3赞 392
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 162,277评论 0赞 353
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,132评论 1赞 292
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,147评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,106评论 1赞 295
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,019评论 3赞 417
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,862评论 0赞 274
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,301评论 1赞 310
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,521评论 2赞 332
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,682评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,405评论 5赞 343
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,996评论 3赞 325
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,651评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,803评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,674评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,563评论 2赞 352