90 分钟 10 个手写案例，从源码底层给你讲解 7 种线程池创建方式

关注
发布于: 2020 年 12 月 18 日
我记得之前在面试的时候，面试官问我单线程池有什么意义？我跟面试官说：虽然是单线程池，但提供了工作队列，生命周期管理，工作线程维护等功能。
﻿
虽然有点笼统，但是谁又能说我说的有错呢，单线程，无论是在面试得过程中还是日常开发，都算是一个很重要的知识点，今天没什么事情，我就结合源码+手写得案例，带大家看一下线程吃的7种创建方式
﻿
﻿
1.FixedThreadPool创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。
﻿
源码
﻿
﻿
使用示例如下：
﻿
package com.test.thread;
﻿
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 19:23
 * @description：测试FixedThreadPool
 */
public class testThread1 {
    public static void fixedThreadPool() {
        // 创建 2 个数据级的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
﻿
        // 创建任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
            }
        };
﻿
        // 线程池执行任务(一次添加 4 个任务)
        // 执行任务的方法有两种:submit 和 execute
        threadPool.submit(runnable);  // 执行方式 1:submit
        threadPool.execute(runnable); // 执行方式 2:execute
        threadPool.execute(runnable);
        threadPool.execute(runnable);
﻿
﻿
    }
﻿
    public static void main(String[] args) {
            fixedThreadPool();
    }
}
﻿
执行结果如下：
﻿
﻿
后来我将测试数量提交到100，而线程池中处理线程得数量增加到4
﻿
﻿
执行结果
﻿
﻿
最开始，提交4个线程执行，之后的线程会在队列中排序等待被执行
﻿
如果觉得以上方法比较繁琐，还可以用更简单的使用方法，如下代码所示：
﻿
package com.test.thread;
﻿
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 19:27
 * @description：FixedThreadPool进阶写法
 */
public class testThreadG {
    public static void fixedThreadPool() {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
       /*
       * 执行任务
       * 为了个之前得进行统一，所以这里通过for循环，同样是提交4个执行*/
        for(int i=1;i<=4;i++) {
            threadPool.execute(() -> {
                System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
            });
        }
    }
﻿
    public static void main(String[] args) {
        fixedThreadPool();
    }
}
﻿
2.CachedThreadPool创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。
﻿
源码
﻿
﻿
参数详解：
﻿
corePoolSize = 0，
maximumPoolSize设置为Integer.MAX_VALUE，代表没有核心线程，非核心线程是无界的；keepAliveTime = 60L，空闲线程等待新任务的最长时间是60s；
用了阻塞队列SynchronousQueue,是一个不存储元素的阻塞队列
﻿
使用示例如下：
﻿
package com.test.thread;
﻿
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 19:38
 * @description：测试CachedThreadPool
 */
public class testThread2 {
    public static void cachedThreadPool() {
        // 创建线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        // 执行任务
        for (int i = 0; i < 10; i++) {
            threadPool.execute(() -> {
                System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
            });
        }
    }
﻿
    public static void main(String[] args) {
        cachedThreadPool();
    }
}
}
﻿
执行结果如下：
﻿
﻿
从上述结果可以看出，线程池创建了 10 个线程来执行相应的任务。
﻿
而如果我将sleep注释之后，再来看执行结果
﻿
﻿
我想这个结果一目了然吧，大家如果可以的话，可以把这个执行数据提升一下，然后再查看一下结果应该会更明显
﻿
3.SingleThreadExecutor创建单个线程数的线程池，它可以保证先进先出的执行顺序。为了能让大家看的更清楚，所以每个线程在执行得时候我都添加了他的时间
﻿
使用示例如下：
﻿
package com.test.thread;
﻿
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 20:17
 * @description：测试singleThreadExecutor
 */
public class testThread4 {
﻿
    public static void singleThreadExecutor() {
        // 创建线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 执行任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
﻿
            threadPool.execute(() -> {
                new Thread();
                System.out.println(Thread.currentThread().getName()+"开始时间[" + new java.util.Date().getTime());
                System.out.println(index + ":任务被执行");
﻿
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName()+"结束时间[" + new java.util.Date().getTime());
            });
        }
    }
﻿
    public static void main(String[] args) {
       singleThreadExecutor();
﻿
    }
}
﻿
执行结果如下：
﻿
﻿
4.ScheduledThreadPool创建一个可以执行延迟任务的线程池。
﻿
源码
﻿
这个线程得源码有一点特殊，由两部分组成，第一部分
﻿
﻿
这里创建了ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，主要用于给定 延时之后的运行任务或定期处理任务
﻿
第二部分
﻿
﻿
使用示例如下：
﻿
package com.test.thread;
﻿
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 20:43
 * @description：测试ScheduledThreadPool
 */
public class testThread3 {
    public static void scheduledThreadPool() {
        // 创建线程池
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
        // 添加定时执行任务(1s 后执行)
        for(int i=0;i<4;i++){
            final int index=i;
﻿
        System.out.println(index+"添加任务,时间:" + new Date()+Thread.currentThread().getName());
        threadPool.schedule(() -> {
            System.out.println(index+"任务被执行,时间:" + new Date()+Thread.currentThread().getName());
           /* try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }*/
        }, 1, TimeUnit.SECONDS);
    }
    }
    public static void main(String[] args) {
        scheduledThreadPool();
    }
}
﻿
执行结果如下：
﻿
﻿
5.SingleThreadScheduledExecutor创建一个单线程的可以执行延迟任务的线程池。
﻿
使用示例如下：
﻿
package com.test.thread;
﻿
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 20:54
 * @description：测试SingleThreadScheduledExecutor
 */
public class testThread5 {
    public static void SingleThreadScheduledExecutor() {
        // 创建线程池
        ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
        // 添加定时执行任务(2s 后执行)
        for (int i=0;i<4;i++) {
﻿
    final  int index=i;
            System.out.println(index+"添加任务,时间:" + new Date());
            threadPool.schedule(() -> {
                System.out.println(index+"任务被执行,时间:" + new Date());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
            }, 2, TimeUnit.SECONDS);
        }
    }
﻿
    public static void main(String[] args) {
        SingleThreadScheduledExecutor();
    }
}
﻿
执行结果如下：
﻿
﻿
从上述结果可以看出，任务在 2 秒之后被执行了，符合我们的预期。
﻿
6.newWorkStealingPool创建一个抢占式执行的线程池（任务执行顺序不确定）
﻿
注意：
﻿
此方法只有在 JDK 1.8+ 版本中才能使用。
﻿
使用示例如下：
﻿
public static void workStealingPool() {
    // 创建线程池
    ExecutorService threadPool = Executors.newWorkStealingPool();
    // 执行任务
    for (int i = 0; i < 10; i++) {
        final int index = i;
        threadPool.execute(() -> {
            System.out.println(index + " 被执行,线程名:" + Thread.currentThread().getName());
        });
    }
    // 确保任务执行完成
    while (!threadPool.isTerminated()) {
    }
}
﻿
执行结果如下：
﻿
﻿
7.ThreadPoolExecutor最原始的创建线程池的方式，它包含了 7 个参数可供设置。
﻿
使用示例如下：
﻿
package com.test.thread;
﻿
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
﻿
/**
 * @author ：biws
 * @date ：Created in 2020/12/17 21:07
 * @description：测试ThreadPoolExecutor
 */
public class testThread7 {
    public static void myThreadPoolExecutor() {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5,
                10,
                100,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
        // 执行任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threadPool.execute(() -> {
                System.out.println(index + " 被执行,线程名:" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
﻿
    public static void main(String[] args) {
        myThreadPoolExecutor();
    }
}
﻿
执行结果如下：
﻿
﻿
ThreadPoolExecutor 参数介绍就像我前面説的，ThreadPoolExecutor 是可以设置一些参数的，在我的代碼中，我只设置了这几个参数
﻿
﻿
在源码中是这样编写的
﻿
    public ThreadPoolExecutor(
      												int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
﻿
7 个参数代表的含义如下：
﻿
corePoolSize
﻿
核心线程数，线程池中始终存活的线程数。
﻿
maximumPoolSize
﻿
最大线程数，线程池中允许的最大线程数，当线程池的任务队列满了之后可以创建的最大线程数。
﻿
keepAliveTime \ unit:
﻿
最大线程数可以存活的时间，当线程中没有任务执行时，最大线程就会销毁一部分，最终保持核心线程数量的线程。
﻿
单位是和参数 3 存活时间配合使用的，合在一起用于设定线程的存活时间
﻿
threadFactory
﻿
线程工厂，主要用来创建线程，默认为正常优先级、非守护线程。
﻿
workQueue
﻿
一个阻塞队列，用来存储线程池等待执行的任务，均为线程安全，它包含以下 7 种类型：
﻿
ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。
SynchronousQueue：一个不存储元素的阻塞队列，即直接提交给线程不保持它们。
PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。
DelayQueue：一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。
LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似，还含有非阻塞方法。
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
较常用的是 LinkedBlockingQueue 和 Synchronous，线程池的排队策略与 BlockingQueue 有关。
﻿
handler
﻿
拒绝策略，拒绝处理任务时的策略，系统提供了 4 种可选：
﻿
默认策略为 AbortPolicy。
﻿
代码演示
﻿
。。。。。
        // 创建线程,线程的任务队列的长度为 1
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                new ThreadPoolExecutor.DiscardPolicy());
。。。。
﻿
//在Java种共有4种拒绝策略
/*
AbortPolicy：拒绝并抛出异常。
﻿
CallerRunsPolicy：使用当前调用的线程来执行此任务。
﻿
DiscardOldestPolicy：抛弃队列头部（最旧）的一个任务，并执行当前任务。
﻿
DiscardPolicy：忽略并抛弃当前任务。
*/
﻿
演示结果
﻿
﻿
我们创建了一个核心线程数和最大线程数都为 1 的线程池，并且给线程池的任务队列设置为 1，这样当我们有 2 个以上的任务时就会触发拒绝策略，
﻿
自定义拒绝策略除了 Java 自身提供的 4 种拒绝策略之外，我们也可以自定义拒绝策略，示例代码如下：
﻿
。。。
﻿
        // 创建线程,线程的任务队列的长度为 1
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        // 执行自定义拒绝策略的相关操作
                        System.out.println("我是自定义拒绝策略~");
                    }
                });
﻿
。。。
﻿
程序的执行结果如下：
﻿
﻿
线程池的执行流程提交一个任务到线程池中，线程池的处理流程如下：
﻿
1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
﻿
2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
﻿
3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。
﻿
﻿
总结今天，我花费90分钟得时间，一点点得手敲案例，将7个线程池的创建方式进行讲解，但是在日常得生活中，我应用最多的就是hreadPoolExecutor，因为他的参数以及拒绝策略有时会让开发过程更加可控一些，并且支持自定义，这就很6
﻿
希望本文的内容能帮助到你。原创不易，觉得不错就点个赞再走吧！
喜欢的小伙伴可以关注公众号：小迁不秃头，每天不定时更新，干货满满！
﻿