我记得之前在面试的时候，面试官问我单线程池有什么意义？我跟面试官说：虽然是单线程池，但提供了工作队列，生命周期管理，工作线程维护等功能。

虽然有点笼统，但是谁又能说我说的有错呢，单线程，无论是在面试得过程中还是日常开发，都算是一个很重要的知识点，今天没什么事情，我就结合源码+手写得案例，带大家看一下线程吃的7种创建方式

文章首发公众号：Java架构师联盟，每日更新技术好文

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

来源：https://www.cnblogs.com/biwz/p/14154947.html