系列文章目录

多线程实现（一）——概念和三种实现多线程实操
 多线程实现（二）——线程池实现多线程

文章目录

系列文章目录
前言
一、线程池的优势有哪些？
二、线程池实现多线程实践
总结

前言

上一篇文章讲了线程的三种实现方式，但在实际项目开发中，基本用不到找这些方法，而通常用线程池来实现，为什么这样子呢？是因为我们继承Thread、实现Runable、实现FutureTask这三种线程方法无法控制线程，可能造成线系统资源浪费，性能下降；所以必须使用线程池，构建多线程；让线程充分利用，降低系统的资源消耗。(就像救济站发放免费的食物，对前来领取的人不限制，结果大家一窝蜂全来了，本来只能容纳30人的房间，瞬间撑爆。星爷的电影《破坏之王》有一个片段是排队买学友的电影票，结果阿婆一个人直接买光了，场面一度混乱哈哈哈)
在这里插入图片描述

拓展：
问题：执行一个java任务，可以直接new Thread来运行任务，线程从创建到消耗都经历了哪些过程？
答：①创建java线程实例，线程也是一个对象实例（像new），堆内存中分配内存（需要消耗时间和内存）；
②执行start方式启动（操作系统为java线程创建对应的内核线程，线程处于就绪状态。需要时间和内存）
③（内核）线程被操作系统CPU调度选中后，线程开始执行（run方法开始运行）
④JVM开始为线程创建线程私有资源：JVM虚拟机栈*程序计数器（需要时间和内存）
⑤线程运行过程中，cpu上下文切换（消耗时间，频繁切换，影响性能）
⑥线程运行完毕，java线程被垃圾回收器回收（销毁内存需要时间）
总结：
线程不仅是java对象，更是操作系统的资源（创建和消耗线程都需要时间）；
java线程的创建和运行都需要内存空间（线程数量太多，消耗很多内存）；
cpu上下文换（线程数量一大，cpu频繁切换）；

提示：以下是本篇文章正文内容，下面案例可供参考

一、线程池的优势有哪些？

降低系统资源的消耗；提供系统的响应速度；方便管理（线程复用，控制最大并发数，管理线程）；
即事先创建好一些资源，有人要用（类比业务系统需要用线程），就来我这里拿（线程池），用完之后不销毁必须还给我（线程池的复用）

二、线程池实现多线程实践

2.1、第一种：创建线程池对象；创建单个线程的线程池对象

代码如下（示例）：

public class ThreadPool {
    public static void main(String[] args) {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            //线程执行
            try{
                executorService.execute(()->{
                    System.out.println("使用executor方式实现多线程.....");
                    //业务代码
                    int i = 99 / 3;
                    System.out.println("业务代码执行结果：" + i);
                });
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                //线程池用完，关闭线程池
                executorService.shutdown();
            }
    }
}

2.2、第二种：创建固定数量的线程池(指定核心线程数数量)

代码如下（示例）：

public class ThreadPool {
    public static void main(String[] args) {
            ExecutorService executorService2 = Executors.newFixedThreadPool(2);
            //线程执行
            try{
                executorService2.execute(()->{
                    System.out.println("使用executor方式实现多线程.....");
                    //业务代码
                    int i = 99 / 3;
                    System.out.println("业务代码执行结果：" + i);
                });
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                //线程池用完，关闭线程池
                executorService2.shutdown();
            }
    }
}

2.3、第三种：创建一个按照计划执行的线程池

代码如下（示例）：

public class ThreadPool {
    public static void main(String[] args) {
            ScheduledExecutorService executorService3 = Executors.newScheduledThreadPool(2);
            //线程执行
            try{
                executorService3.execute(()->{
                    System.out.println("使用executor方式实现多线程.....");
                    //业务代码
                    int i = 99 / 3;
                    System.out.println("业务代码执行结果：" + i);
                });
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                //线程池用完，关闭线程池
                executorService3.shutdown();
            }
    }
}

2.4、第四种：创建一个自动增长的线程池

代码如下（示例）：

public class ThreadPool {
    public static void main(String[] args) {
            ExecutorService executorService4 = Executors.newCachedThreadPool();
            //线程执行
            try{
                executorService4.execute(()->{
                    System.out.println("使用executor方式实现多线程.....");
                    //业务代码
                    int i = 99 / 3;
                    System.out.println("业务代码执行结果：" + i);
                });
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                //线程池用完，关闭线程池
                executorService4.shutdown();
            }
    }
}

上面四种创建方式仅用于学习。不建议在项目中使用。原因是：当线程量一大后，可能造成无限制创建线程，导致内存被占满，线程量大导致性能严重下降，甚至OOM；

2.5、使用 ThreadPoolExecutor 类创建线程池（解决无限制创建线程，推荐项目中使用）

代码如下（示例）：

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

参数解析：
1、corePoolSize：线程池核心线程数，初始化线程池时候，会创建
核心线程等待状态，核心线程不会被销毁，提供线程的复用；
2、maximumPoolSize: 最大线程数；核心线程用完了，必须新建线程
执行任务，但是新建的线程不能超过最大线程数；
3、keepAliveTime：线程存活时间，除了核心线程以为
（maximumPoolSize- corePoolSize）的线程存活时间；当线程处于空闲状态，他可以活多久；
4、unit: 存活时间单位
5、workQueue：任务阻塞队列，任务可能会很多，线程就那么几个，
因此可以把多余的任务放入队列进行缓冲，队列采用 FIFO 的，等待线程空闲，再从队列取出任务执行；
6、threadFactory：线程工厂，默认使用 defaultthreadFactory, 用来创建线程的，一般使用默认即可；
7、RejectedExecutionHandler：线程池拒绝策略
四种拒绝策略：
(1)、AbortPolicy : 新任务直接被拒绝，抛出异常：
(2)、DisCardPolicy: 队列满了，新任务忽略不执行，直接丢弃，不会抛出异常
(3)、DisCardOldestPolicy: 队列满了，新任务尝试和等待最久的线程竞争，也不会抛出异常；抛弃任务队列中等待最久任务，新任务直接添加到队列中
(4)、CallerRunPolicy: 新任务来临后，直接使用调用者所在线程执行任务即可

public class ThreadPool {
    public static void main(String[] args) {
        /**
         * !!! 使用此种线程池，不会有资源耗尽的风险
         * 合理配置相关参数： 【最大线程数设置公式：（任务执行时间/任务cpu时间）* N】
         *   1.cpu密集型任务（所有任务都在内存中执行，没有磁盘的读写）
         *    核心线程数：服务器cpu核心数
         *    最大线程数：cpu核心数+1
         *   2.IO密集型（有大量的磁盘读写任务，cpu出于空闲状态）
         *    核心线程数：cpu核心数
         *    最大线程数：2N+1
         *
         */
        //可伸缩的线程创建（更加可控）
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                Runtime.getRuntime().availableProcessors(), //线程池核心线程数（这里获取程序所在服务器的最大线程数）
                13, //最大个数要不小于核心线程数
                3,  //线程存活时间   
                TimeUnit.SECONDS,  //存活时间单位
                new LinkedBlockingQueue<>(3),  //队列可装，装满后队列可伸缩再装三个
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        try{
             for(int i = 0; i < 10; i++ ){
                threadPool.execute(()->{
                    System.out.println("使用executor方式实现多线程.....");
                    //业务代码
                    int j = 99 / 3;
                    System.out.println("业务代码执行结果：" + j);
                });
	      	 }
        }catch(Exception e){
                e.printStackTrace();
        }finally{
            //线程池用完，关闭线程池
            threadPool.shutdown();
        }
    }
}

总结

合理配置线程相关的参数：核心线程数，最大线程数
设置线程系线程数的数量：根据业务类型进行设置（cpu 密集型，Io 密集型）
如果 CPU 密集型任务（所有任务都在内存中执行：没有磁盘的读写）：建议线程池最大数量设置为 N(cpu 核心数量)+1
如果 IO 密集型任务（大量磁盘读写任务）：如果有 IO 操作，cpu 此时处于空闲状态，最大线程数应该设置：2N+1
最大线程数设置公式：最大线程数 = （任务执行时间 / 任务 cpu 时间）*N
参数workQueue队列的选择
1）使用队列，可以让任务在队列中进行缓存；可以线程执行防洪泄流的效果，提升线程池的任务能力
2）如何选择合适的队列？
基于 Java 一些队列实现特性：
1、ArrayBlockingQueue : 基于数组实现的有界的阻塞队列（有界的队列）
2、LinkedBlockingQueue: 基于链表实现的有界阻塞队列
3、PriorityBlockingQueue: 支持按照优先级排序的无界的阻塞的队列
4、DelayQueue: 优先级实现的无界阻塞队列
5、SynchronousQueue : 只存储一个元素，如果这个元素没有被消费，不能在向里面存储元素
6、LinkedTransferQueue: 基于链表实现的无界的阻塞队列
7、LinkedBlockingDeque: 基于链表实现的双向的无界阻塞的队列
如何选择一个合适的队列：建议必须使用有界队列。
有界队列能增加系统的稳定性，根据需求设置大一些（可控设置）；如果设置为无界队列，
遇到不可控的因素，可能会导致队列中的任务越来越多，出现 OOM，撑爆整个系统；