为什么要使用线程池？线程创建不好使？

渐暖°

已于 2023-07-18 11:11:00 修改

阅读量1.4k

点赞数

分类专栏： # 【并发编程】文章标签： java 多线程

于 2020-08-14 20:03:43 首次发布

本文链接：https://blog.csdn.net/yujing1314/article/details/107530928

版权

【并发编程】专栏收录该内容

2 篇文章 0 订阅

订阅专栏

多线程提高了任务的执行效率，操作系统中，线程的运行状态分为新建、就绪、运行、阻塞、结束

			      运行 ------> 结束   
                  / \
                 /   \
新建-------> 就绪<-----阻塞

线程一旦start开始到结束，就不能重新start了，就需要重新创建线程，而线程池通过重用已存在的线程，降低线程创建和销毁造成的消耗，并且提供了更强大的功能，比如延时定时线程池

java中线程的状态有6种
在这里插入图片描述

Executor框架

在这里插入图片描述
1、Executor

顶层Executor接口，只有execute 方法，execute 可以提交任务

2、ExecutorService

ExecutorService继承了Executor，比Executor功能要多，定义了线程池的相关操作

3、AbstractExecutorService

提供了 ExecutorService 的部分默认实现。

4、ThreadPoolExecutor

实际上我们使用的线程池的实现是 ThreadPoolExecutor。它实现了线程池工作的完整机制。主要的使用的就是它

5、ForkJoinPool

实现 Fork/Join 模式的线程池

6、ScheduledExecutorService

这个接口扩展了ExecutorService，定义个延迟执行和周期性执行任务的方法。

7、ScheduledThreadPoolExecutor

此接口则是在继承 ThreadPoolExecutor 的基础上实现 ScheduledExecutorService 接口，提供定时和周期执行任务的特性。

Executors

Executor 框架还提供 Executors 对象。注意看这个对象比 Executor 接口后面对了个 s，要区分开，不要搞混。Executors 是一个工厂及工具类。提供了例如 newFixedThreadPool(10) 的方法，来创建各种不同的 Executor。

为什么不推荐使用Executor操纵线程

《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。

自定义线程池

ThreadPoolExecutor

6个参数(默认值)

corePoolSize=1

queueCapacity=Integer.MAX_VALUE

maxPoolSize=Integer.MAX_VALUE

keepAliveTime=60s

allowCoreThreadTimeout=false

rejectedExecutionHandler=AbortPolicy()

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> 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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

参数默认值和解释

在这里插入图片描述

1. corePoolSize=1:
corePoolSize 线程池核心线程大小,核心线程数=每秒有多少个线程处理，如果是CPU密集型那么核心线程数就是核数+1；如果是IO密集型就有一个公式来计算

2. maximumPoolSize 线程池最大线程数量
线程池中允许的最大线程数

3.keepAliveTime 空闲线程存活时间
线程池工作线程空闲后，保持的存活时间

4. unit ：
上面时间的单位

5.workQueue 工作队列
4种队列
①ArrayBlockingQueue

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

②LinkedBlockingQuene

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

③SynchronousQuene

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

④PriorityBlockingQueue

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

6.threadFactory 线程工厂
创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等

7.rejectedExecutionHandler=AborPolicy()
任务不重要可以丢弃，任务重要则要利用一些缓冲机制来处理

AbortPolicy：直接抛异常。
DiscardPolicy：顾名思义，直接丢弃多余的任务。
DiscardOldestPolicy：丢弃队列中最老的任务，并且重试exexute方法，并发书中说丢弃最新的一个任务，这边书中应该描述错了。
CallerRunsPolicy：在调用线程中执行丢弃的任务。
也可以自定义拒绝策略，比如记录日志或者持久化处理。

**keepAliveTime和threadFactory **
一般采取默认值

线程池的实现原理

提交一个新的任务到线程池中，线程池的处理流程：
1）线程池判断核心线程池里的线程是否都在执行任务。如果不是（也就是当前执行任务的线程数小于核心线程数corePoolSize），则创建一个新的线程执行任务。如果线程池中的线程都在执行任务，也就是说当前的工作线程数大于等于corePoolSize），则进入下个流程
2）线程池判断工作队列（一般是阻塞队列BlockingQueue）是否已经满了。如果工作队列没有满，则将任务增加到工作队列中。如果工作队列满了，则进入下个流程，
3）线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略（或者叫做拒绝策略）来处理这个任务。

无界队列

与有界队列相比，除非系统资源耗尽，否则无界的队列不存在任务入队失败的情况。当有新任务到来，系统的线程小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加。若后续仍有新的队列加入，而没有空闲的线程资源，则队列直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。
所以一般不建议使用无界队列

线程池的状态

在这里插入图片描述

线程池的五种状态:Running、ShutDown、Stop、Tidying、Terminated

线程池的相关操作

1.线程池如何提交任务

提交无返回值的任务（execute()）；

提交有返回值的任务（submit())

2.线程池如何关闭

shutdown

shutdownnow

为什么要使用线程池

为了减少创建和销毁线程的次数，让每个线程可以多次使用,可根据系统情况调整执行的线程数量，防止消耗过多内存,所以我们可以使用线程池.

线程池工具类

单例模式

public class ThreadPoolUtil {
    //线程池对象
    public ThreadPoolExecutor poolExecutor;
    //构造函数私有化
    private ThreadPoolUtil(){
        //完成线程池对象的实例化
        poolExecutor=new ThreadPoolExecutor(4,10,3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(20), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
    }
    //静态内部类 完成对象的实例化 
    private static class PoolInner{
        private final static ThreadPoolUtil pool=new ThreadPoolUtil();
    }
    //获取唯一实例
    public static ThreadPoolUtil getInstance(){
        return PoolInner.pool;
    }
}