Java知识【线程池】

红太狼 2023-10-02 22:06 10阅读 0赞

### 1.线程池 ###

#### 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种状态，每种线程状态的含义如下

<table> 
 <thead> 
  <tr> 
   <th>线程状态</th> 
   <th>具体含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>NEW</td> 
   <td>一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。</td> 
  </tr> 
  <tr> 
   <td>RUNNABLE</td> 
   <td>当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。</td> 
  </tr> 
  <tr> 
   <td>BLOCKED</td> 
   <td>当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。</td> 
  </tr> 
  <tr> 
   <td>WAITING</td> 
   <td>一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。</td> 
  </tr> 
  <tr> 
   <td>TIMED_WAITING</td> 
   <td>一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。</td> 
  </tr> 
  <tr> 
   <td>TERMINATED</td> 
   <td>一个完全运行完成的线程的状态。也称之为终止状态、结束状态</td> 
  </tr> 
 </tbody> 
</table>

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

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CZmZok9Y-1665751776645)(.\\img\\1591163781941.png)\]][img-CZmZok9Y-1665751776645_._img_1591163781941.png]

#### 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 线程池-参数详解 ####

![bcece722e2214cfc8a10edf4a5255b4e.png][]

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler)
        
    corePoolSize：   核心线程的最大值，不能小于0
    maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize
    keepAliveTime：  空闲线程最大存活时间,不能小于0
    unit：           时间单位
    workQueue：      任务队列，不能为null
    threadFactory：  创建线程工厂,不能为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) {
        
    
            /**
             * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
             */
            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) {
        
            /**
             * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
             */
            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) {
        
            /**
             * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
             */
            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---->> 执行了任务2
    pool-1-thread-1---->> 执行了任务0
    pool-1-thread-3---->> 执行了任务3
    pool-1-thread-1---->> 执行了任务4

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

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

public class ThreadPoolExecutorDemo04 {
        
        public static void main(String[] args) {
        
    
            /**
             * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
             */
            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()方法绕过线程池直接执行。

[img-CZmZok9Y-1665751776645_._img_1591163781941.png]: https://img-blog.csdnimg.cn/ce1cbd3ea52c4967ad91660116c5becb.png
[bcece722e2214cfc8a10edf4a5255b4e.png]: https://img-blog.csdnimg.cn/bcece722e2214cfc8a10edf4a5255b4e.png