从零开始学习 Java：简单易懂的入门指南之线程池（三十六）

线程池

• • 1.1 线程状态介绍
  • 1.2 线程池-基本原理
  • 1.3 线程池-Executors默认线程池
  • 1.4 线程池-Executors创建指定上限的线程池
  • 1.5 线程池-ThreadPoolExecutor
  • 1.6 线程池-参数详解
  • 1.7 线程池-非默认任务拒绝策略

1.1 线程状态介绍

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程

状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：

public class Thread {        public enum State {                    NEW ,                 RUNNABLE ,                 BLOCKED ,                 WaiTING ,                 TIMED_WAITING ,                 TERMINATED;    }        // 获取当前线程的状态    public State getState() {        return jdk.internal.misc.VM.toThreadState(threadStatus);    }    }

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

各个状态的转换，如下图所示：

1.2 线程池-基本原理

概述 :

​ 提到池，大家应该能想到的就是水池。水池就是一个容器，在该容器中存储了很多的水。那么什么是线程池呢？线程池也是可以看做成一个池子，在该池子中存储很多个线程。

线程池存在的意义：

​ 系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系

​ 统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就

​ 会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

线程池的设计思路 :

1. 准备一个任务容器
2. 一次性启动多个(2个)消费者线程
3. 刚开始任务容器是空的，所以线程都在wait
4. 直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
5. 这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来

1.3 线程池-Executors默认线程池

概述 : JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。

我们可以使用Executors中所提供的静态方法来创建线程池

​ static ExecutorService newCachedThreadPool() 创建一个默认的线程池
​ static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池

代码实现 :

package com.itheima.mythreadpool;//static ExecutorService newCachedThreadPool()   创建一个默认的线程池//static newFixedThreadPool(int nThreads)    创建一个指定最多线程数量的线程池import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class MyThreadPoolDemo {    public static void main(String[] args) throws InterruptedException {        //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.        ExecutorService executorService = Executors.newCachedThreadPool();        //Executors --- 可以帮助我们创建线程池对象        //ExecutorService --- 可以帮助我们控制线程池        executorService.submit(()->{            System.out.println(Thread.currentThread().getName() + "在执行了");        });        //Thread.sleep(2000);        executorService.submit(()->{            System.out.println(Thread.currentThread().getName() + "在执行了");        });        executorService.shutdown();    }}

1.4 线程池-Executors创建指定上限的线程池

使用Executors中所提供的静态方法来创建线程池

​ static ExecutorService newFixedThreadPool(int nThreads) : 创建一个指定最多线程数量的线程池

代码实现 :

package com.itheima.mythreadpool;//static ExecutorService newFixedThreadPool(int nThreads)//创建一个指定最多线程数量的线程池import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ThreadPoolExecutor;public class MyThreadPoolDemo2 {    public static void main(String[] args) {        //参数不是初始值而是最大值        ExecutorService executorService = Executors.newFixedThreadPool(10);        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;        System.out.println(pool.getPoolSize());//0        executorService.submit(()->{            System.out.println(Thread.currentThread().getName() + "在执行了");        });        executorService.submit(()->{            System.out.println(Thread.currentThread().getName() + "在执行了");        });        System.out.println(pool.getPoolSize());//2//        executorService.shutdown();    }}

1.5 线程池-ThreadPoolExecutor

创建线程池对象 :

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

代码实现 :

package com.itheima.mythreadpool;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.Executors;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class MyThreadPoolDemo3 {//    参数一：核心线程数量//    参数二：最大线程数//    参数三：空闲线程最大存活时间//    参数四：时间单位//    参数五：任务队列//    参数六：创建线程工厂//    参数七：任务的拒绝策略    public static void main(String[] args) {        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());        pool.submit(new MyRunnable());        pool.submit(new MyRunnable());        pool.shutdown();    }}

1.6 线程池-参数详解

public ThreadPoolExecutor(int corePoolSize,  int maximumPoolSize,  long keepAliveTime,  TimeUnit unit,  BlockingQueue<Runnable> workQueue,  ThreadFactory threadFactory,  RejectedExecutionHandler handler)    corePoolSize：   核心线程的最大值，不能小于0maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSizekeepAliveTime：  空闲线程最大存活时间,不能小于0unit：           时间单位workQueue：      任务队列，不能为nullthreadFactory：  创建线程工厂,不能为null      handler：        任务的拒绝策略,不能为null  

1.7 线程池-非默认任务拒绝策略

RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。

ThreadPoolExecutor.AbortPolicy:     丢弃任务并抛出RejectedExecutionException异常。是默认的策略。ThreadPoolExecutor.DiscardPolicy：    丢弃任务，但是不抛出异常 这是不推荐的做法。ThreadPoolExecutor.DiscardOldestPolicy：    抛弃队列中等待最久的任务 然后把当前任务加入队列中。ThreadPoolExecutor.CallerRunsPolicy:        调用任务的run()方法绕过线程池直接执行。

注：明确线程池对多可执行的任务数 = 队列容量 + 最大线程数

案例演示1：演示ThreadPoolExecutor.AbortPolicy任务处理策略

public class ThreadPoolExecutorDemo01 {    public static void main(String[] args) {                ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常        for(int x = 0 ; x < 5 ; x++) {            threadPoolExecutor.submit(() -> {                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");            });        }    }}

控制台输出结果

pool-1-thread-1---->> 执行了任务pool-1-thread-3---->> 执行了任务pool-1-thread-2---->> 执行了任务pool-1-thread-3---->> 执行了任务

控制台报错，仅仅执行了4个任务，有一个任务被丢弃了

案例演示2：演示ThreadPoolExecutor.DiscardPolicy任务处理策略

public class ThreadPoolExecutorDemo02 {    public static void main(String[] args) {                ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错        for(int x = 0 ; x < 5 ; x++) {            threadPoolExecutor.submit(() -> {                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");            });        }    }}

控制台输出结果

pool-1-thread-1---->> 执行了任务pool-1-thread-1---->> 执行了任务pool-1-thread-3---->> 执行了任务pool-1-thread-2---->> 执行了任务

控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了

案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略

public class ThreadPoolExecutorDemo02 {    public static void main(String[] args) {                ThreadPoolExecutor threadPoolExecutor;        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());        // 提交5个任务        for(int x = 0 ; x < 5 ; x++) {            // 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰            final int y = x ;            threadPoolExecutor.submit(() -> {                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y);            });             }    }}

控制台输出结果

pool-1-thread-2---->> 执行了任务2pool-1-thread-1---->> 执行了任务0pool-1-thread-3---->> 执行了任务3pool-1-thread-1---->> 执行了任务4

由于任务1在线程池中等待时间最长，因此任务1被丢弃。

案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略

public class ThreadPoolExecutorDemo04 {    public static void main(String[] args) {                ThreadPoolExecutor threadPoolExecutor;        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());        // 提交5个任务        for(int x = 0 ; x < 5 ; x++) {            threadPoolExecutor.submit(() -> {                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");            });        }    }}

控制台输出结果

pool-1-thread-1---->> 执行了任务pool-1-thread-3---->> 执行了任务pool-1-thread-2---->> 执行了任务pool-1-thread-1---->> 执行了任务main---->> 执行了任务

通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。

后记
👉👉💕💕美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ 🌹🌹🌹

来源地址：https://blog.csdn.net/m0_59230408/article/details/132643519