多线程和线程池工作原理解析深入浅出

Dear 丶 2024-04-01 16:01 12阅读 0赞

**目录**

一、创建线程的4种方式

1.1继承Thread类

1.2实现Runnable接口

1.3实现Callable接口 【有返回值】

1.4线程池

二、线程同步方法

2.1 wait()

2.2 sleep()

2.3 notify()

2.4 notifyAll()

三、线程的几种状态

3.1.新建状态

3.2.就绪状态

3.3.运行状态

3.4.阻塞状态

3.5.死亡状态

四、多线程中 start() 和 run() 区别

4.1.start()

4.2.run()

五、线程中 sleep（）和wait（）的区别

代码

六、JAVA实现多线程 及 线程池

6.1.继承Thread来实现多线程

6.2.通过实现Runnable接口来实现

6.3.通过Callable来实现一个Thread

二者实现多线程的区别

线程池工作原理

五种实现

七个核心参数

CPU密集型

IO密集型

四种策略

拒绝策略执行则么办？

线程池五种状态

线程池工作原理

--------------------

那为什么要使用线程池？其实，这个问题可以反过来思考一下，不使用线程池会怎么样？当需要多线程并发执行任务时，只能不断的通过new Thread创建线程，每创建一个线程都需要在堆上分配内存空间，同时需要分配虚拟机栈、本地方法栈、程序计数器等线程私有的内存空间，当这个线程对象被可达性分析算法标记为不可用时被GC回收，这样频繁的创建和回收需要大量的额外开销。

再者说，JVM的内存资源是有限的，如果系统中大量的创建线程对象，JVM很可能直接抛出OutOfMemoryError异常，还有大量的线程去竞争CPU会产生其他的性能开销，更多的线程反而会降低性能，所以必须要限制线程数。

## 一、创建线程的4种方式 ##

在JDK1.5之前，创建线程就只有两种方式，即继承java.lang.Thread类和实现java.lang.Runnable接口；

而在JDK1.5以后，增加了两个创建线程的方式，即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现

### 1.1继承Thread类 ###

//继承Thread类来创建线程
    public class ThreadTest {
     
        public static void main(String[] args) {
            //设置线程名字
            Thread.currentThread().setName("main thread");
            MyThread myThread = new MyThread();
            myThread.setName("子线程:");
            //开启线程
            myThread.start();
            for(int i = 0;i<5;i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
     
    class MyThread extends Thread{
        //重写run()方法
        public void run(){
            for(int i = 0;i < 10; i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

### 1.2实现Runnable接口 ###

// 实现Runnable接口
    public class RunnableTest {     
        public static void main(String[] args) {       
            // 设置线程名字       
            Thread.currentThread().setName( "main thread:" );          
            Thread thread =  new Thread( new MyRunnable());        
            thread.setName( "子线程:" );        
            // 开启线程        
            thread.start();        
            for ( int i = 0; i <5;i++){   
                System. out .println(Thread.currentThread().getName() + i);        
            }
        }
    }
     
    class MyRunnable implements Runnable {
        @Override
        public void run() {        
            for ( int i = 0; i < 10; i++) {           
                System. out .println(Thread.currentThread().getName() + i);        
            }    
        }
    }

### 1.3实现Callable接口 【有返回值】 ###

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    //实现Callable接口
    public class CallableTest {
     
        public static void main(String[] args) {
            //执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
            new Thread(futureTask).start();
            //接收线程运算后的结果
            try {
                Integer sum = futureTask.get();
                System.out.println(sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
     
    class MyCallable implements Callable<Integer> {
     
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }

1、最大的区别，runnable没有返回值，而实现callable接口的任务线程能返回执行结果

2、callable接口实现类中的run方法允许异常向上抛出，可以在内部处理，try catch，但是runnable接口实现类中run方法的异常必须在内部处理，不能抛出

### 1.4线程池 ###

线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    // 线程池实现
    public class ThreadPoolExecutorTest {
     
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            ThreadPool threadPool = new ThreadPool();
            for(int i =0;i<5;i++){
                //为线程池分配任务
                executorService.submit(threadPool);
            } 
            // 关闭线程池
            executorService.shutdown();
        }
    }
     
    class ThreadPool implements Runnable {
     
        @Override
        public void run() {
            for(int i = 0 ;i<10;i++){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    
    }

## 二、线程同步方法 ##

线程有4中同步方法，分别为wait()、sleep()、notify()和notifyAll()。

### 2.1 wait() ###

使线程处于一种等待状态，释放所持有的对象锁

### 2.2 sleep() ###

使一个正在运行的线程处于睡眠状态，是一个静态方法，调用它时要捕获InterruptedException异常，不释放对象锁。

### 2.3 notify() ###

唤醒一个正在等待状态的线程。注意调用此方法时，并不能确切知道唤醒的是哪一个等待状态的线程，是由JVM来决定唤醒哪个线程，不是由线程优先级决定的。

### 2.4 notifyAll() ###

唤醒所有等待状态的线程，注意并不是给所有唤醒线程一个对象锁，而是让它们竞争

### 三、线程的几种状态 ###

![18525bc13b1342d1bc46c7fa9b867867.png][]

#### 3.1.新建状态 ####

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

#### 3.2.就绪状态 ####

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度

#### 3.3.运行状态 ####

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态

#### 3.4.阻塞状态 ####

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

*  等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态;
 *  同步阻塞：线程在获取 synchronized同步锁失败(因为同步锁被其他线程占用)。
 *  其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

#### 3.5.死亡状态 ####

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态

### 四、多线程中 start() 和 run() 区别 ###

#### 4.1.start() ####

先来看看Java API中对于该方法的介绍：

使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。

多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体中的代码执行完毕而直接继续执行后续的代码。通过调用Thread类的 start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里的run()方法 称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

#### 4.2.run() ####

同样先看看Java API中对该方法的介绍：

如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

Thread 的子类应该重写该方法。

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

**总结：**

调用start方法方可启动线程，而run方法只是thread类中的一个普通方法调用，还是在主线程里执行。

public static void main(String args[]) {
        Thread t = new Thread() {
              public void run() {
                   pong();
              }
        };
        t.start();
        System.out.print("ping");
    }
     
    static void pong() {
        System.out.print("pang");
    }

输出结果： pingpang

public static void main(String args[]) {
          Thread t = new Thread() {
               public void run() {
                    pong();
               }
          };
          t.run();
          System.out.print("ping");
    }
     
    static void pong() {
         System.out.print("pang");
    }

输出结果：pangping

通过以上两个程序实例，可以很容易的区分出start()方法和run()方法的区别:

t.start(); 该行代码相当于是启动线程，

t.run(); 该行代码相当于是使用t这个类中的run方法而已.

> 线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：
> 
> 1）线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了Thread实例后，线程就进入了初始状态；
> 
> 2）当该对象调用了start()方法，就进入可运行状态；
> 
> 3）进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；
> 
> 4）进入运行状态后涉及的情况就比较多，大致有如下情形： ﹒run()方法或main()方法结束后，线程就进入终止状态； 当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态虽停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片； 当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁住(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配 CPU时间片； 当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由于不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。 当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的 stop。

### 五、线程中 sleep（）和wait（）的区别 ###

共同点

> 1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
> 
> 2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。
> 
> 如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() \{\} 中直接return即可安全地结束线程。 需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。

不同点

> 1.Thread类的方法：sleep(),yield()等 Object的方法：wait()和notify()等
> 
> 2.每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 3.wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
> 
> 4.sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

**线程的调度**

线程调度器按线程的优先级高低选择高优先级线程（进入运行中状态）执行，同时线程调度是抢先式调度，即如果在当前线程执行过程中，一个更高优先级的线程进入可运行状态，则这个线程立即被调度执行。

**抢先式调度又分为：**

时间片方式和独占方式。在时间片方式下，当前活动线程执行完当前时间片后，如果有其他处于就绪状态的相同优先级的线程，系统会将执行权交给其他就绪态的同优先级线程；当前活动线程转入等待执行队列，等待下一个时间片的调度。 在独占方式下，当前活动线程一旦获得执行权，将一直执行下去，直到执行完毕或由于某种原因主动放弃CPU，或者是有一高优先级的线程处于就绪状态。

**举例说明**

首先我想说的是：在多线程编程中，经常会使用sleep与wait操作，我们理解sleep与wait的最大区别是sleep等待是不会释放当前锁，而wait则反之。我今天想到一个现实例子来比较这两者的区别。 我以去火车站买票的例子来说明。我们去火车站买票，当站到售票窗口前要告诉售票员需要到哪里的票，什么时候发车的，售票员就通过电脑去给我们打印票，这个时候我们就得等待。如果我们用sleep模式，就得一直站在那里等，直到售票员给我们票;如果用wait模式，这个时候就离开我们所站的位置，后面的票友就可能站到我当前的位置（窗口前），我们要取票的话，就得重新排在队伍后面去取票。

**线程优先级**

设置和获取线程优先级

// 为线程设置优先级
    public final void setPriority(int newPriority)
    //  获取线程优先级
    public final int getPriority()

进程有进程的优先级，线程也有优先级，理论上是优先级比较高的线程会获得优先被 CPU 调度的机会，但事实上往往并不是这样，设置线程的优先级同样是一个提示操作，具体如下。

*  对于 root 用户，它会提示操作系统你想要设置的优先级别，否则它会被忽略。
 *  如果 CPU 比较忙，设置优先级可能会获得更多的 CPU 时间片，但是闲时优先级的高低几乎不会有任何作用。

所以，不要在程序设计当中企图使用线程优先级绑定某个特定的业务，或者让业务严重依赖线程的优先级。

#### 代码 ####

package concurrent;
    
    public class ThreadPriority {
        public static void main(String[] args) {
            Thread t1 = new Thread(() -> {
                while (true) {
                    System.out.println("t1");
                }
            });
    
            t1.setPriority(3);
            Thread t2 = new Thread(() -> {
                while (true) {
                    System.out.println("t2");
                }
            });
            t2.setPriority(10);
            t1.start();
            t2.start();
        }
    }

运行上面的程序，会发现 t2 出现频率很明显要高一些。

**线程优先级源码分析**

public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
    }

通过分析，可以看到，线程的优先级不能能小于 1 或大于 10，如果指定的线程优先级大于线程所在的 group 的优先级，那么指定的优先级将会被失效，取而代之的是 group 的最大优先级。

package concurrent;
    
    public class ThreadPriority2 {
        public static void main(String[] args) {
            // 顶一个线程组
            ThreadGroup group = new ThreadGroup("test");
            group.setMaxPriority(7);
            Thread t1 = new Thread(group, "test-thread");
            t1.setPriority(10);
            System.out.println(t1.getPriority());
        }
    }

测试结果

线程默认优先级别和它的父类保持一致，一般情况下都是5，main 线程的优先级就是 5，所以它派生出的线程都是5

package concurrent;
    
    public class ThreadPriority3 {
        public static void main(String[] args) {
            Thread t1 = new Thread();
            System.out.println("t1 priority " + t1.getPriority());
    
            Thread t2 = new Thread(() -> {
                Thread t3 = new Thread();
                System.out.println("t3 priority " + t3.getPriority());
            });
            t2.setPriority(6);
            t2.start();
            System.out.println("t2 priority " + t2.getPriority());
        }
    }

测试结果如下

t1 priority 5 // main 方法的优先级
    t2 priority 6 // 显示设置了优先级
    t3 priority 6 // 和父线程保持一致

### 六、JAVA实现多线程 及 线程池 ###

#### 6.1.继承Thread来实现多线程 ####

Java提供了一个超类Thread给我们来extends，一旦继承了它，就可以通过override 其中的run方法，来实现多线程，具体代码如下：

package com.dingtao.test;
    import java.io.*
    public class MyThread extends Thread{
        @Override
        public void run() {   System.out.println(Thread.currentThread().getName());
    
        }
    
    public static void main(String[] args) throws IOException {
    
            Thread t1 = new MyThread();
    
            Thread t2 = new MyThread();
    
            t1.start();
    
            t2.start();
    
        }
    
    }

#### 6.2.通过实现Runnable接口来实现 ####

因为对于一些类来说，他们不能继承Thread来实现多线程，因为Java规定同时只能继承一个超类，但是却可以同时实现多个接口，因此Runnable就更格外受欢迎。具体代码如下：

package com.dingtao.test;
    import java.io.*;
    
    public class MyThread implements Runnable{
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
    
        }
    
        public static void main(String[] args) throws IOException {
            Thread t1 = new Thread(new MyThread());
            Thread t2 = new Thread(new MyThread());
            t1.start();
            t2.start();
        }
    }

#### 6.3.通过Callable来实现一个Thread ####

package com.dingtao.test;
    
    import java.util.concurrent.Callable;
    
    import java.util.concurrent.FutureTask;
    
      
    public class MyThread implements Callable<Integer>{
        public static void main(String[] args){
            MyThread t1 = new MyThread();
            FutureTask<Integer> future = new FutureTask<Integer>(t1);
            new Thread(future,"呵呵哒").start();
        }
    
        @Override
        public Integer call() throws Exception {
            System.out.println(Thread.currentThread().getName());
            return null;
        }
    }

#### 二者实现多线程的区别 ####

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

> 1）：适合多个相同的程序代码的线程去处理同一个资源
> 
> 2）：可以避免java中的单继承的限制
> 
> 3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
> 
> 4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。

从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。

Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。

实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础

### 线程池工作原理 ###

定义：对线程缓存处理，达到统一分配，调优，管理

优点：

>  *  重用线程，减少线程的创建以及消亡的消耗，提高性能
>  *  提高响应速度，任务进来时，快速高效执行任务
>  *  提高线程的可管理性，统一分配，可调优，监管

### 五种实现 ###

1、newSingleThreadExecutor()

【Single单线程池】池里只有一条线程,如果线程因为异常而停止，会自动新建一个线程补充

2、newFixedThreadPool()

【Fixed固定线程池】创建一个核心线程数跟最大线程数相同的线程池,线程池数量大小不变,如果有任务放入队列,等待空闲线程。

3、newCachedThreadPool()

【Cached】线程池是创建一个核心线程数为0，最大线程为Inter.MAX\_VALUE的线程池，线程池数量不确定,有空闲线程则优先使用,没用则创建新的线程处理任务,处理完放入线程池。

4、newScheduledThreadPool()

【Scheduled没有限制】创建一个没有最大线程数限制的可以定时执行线程池,还有创建一个只有单个线程的可以定时执行线程池（Executors.newSingleThreadScheduledExecutor()）

### 七个核心参数 ###

corePoolSize: 线程池核心线程个数
    
    workQueue:用于保存等待执行任务的阻塞队列
    
    maximunPoolSize: 线程池最大线程数量
    
    ThreadFactory: 创建线程的工厂
    
    RejectedExecutionHandler: 队列满，并且线程达到最大线程数量的时候，对新任务的处理策略
    
    keeyAliveTime: 空闲线程存活时间
    
    TimeUnit: 存活时间单位

**corePoolSize(int)**：核心线程数量。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到任务队列当中。线程池将长期保证这些线程处于存活状态，即使线程已经处于闲置状态。除非配置了allowCoreThreadTimeOut=true，核心线程数的线程也将不再保证长期存活于线程池内，在空闲时间超过keepAliveTime后被销毁。

**workQueue**：阻塞队列，存放等待执行的任务，线程从workQueue中取任务，若无任务将阻塞等待。当线程池中线程数量达到corePoolSize后，就会把新任务放到该队列当中。JDK提供了四个可直接使用的队列实现，分别是：基于数组的有界队列ArrayBlockingQueue、基于链表的无界队列LinkedBlockingQueue、只有一个元素的同步队列SynchronousQueue、优先级队列PriorityBlockingQueue。在实际使用时一定要设置队列长度。

**maximumPoolSize**(int)：线程池内的最大线程数量，线程池内维护的线程不得超过该数量，大于核心线程数量小于最大线程数量的线程将在空闲时间超过keepAliveTime后被销毁。当阻塞队列存满后，将会创建新线程执行任务，线程的数量不会大于maximumPoolSize。

**keepAliveTime**(long)：线程存活时间，若线程数超过了corePoolSize，线程闲置时间超过了存活时间，该线程将被销毁。除非配置了allowCoreThreadTimeOut=true，核心线程数的线程也将不再保证长期存活于线程池内，在空闲时间超过keepAliveTime后被销毁。

**TimeUnit** unit：线程存活时间的单位，例如TimeUnit.SECONDS表示秒。

**RejectedExecutionHandler**：拒绝策略，当任务队列存满并且线程池个数达到maximunPoolSize后采取的策略。ThreadPoolExecutor中提供了四种拒绝策略，分别是：抛RejectedExecutionException异常的AbortPolicy(如果不指定的默认策略)、使用调用者所在线程来运行任务CallerRunsPolicy、丢弃一个等待执行的任务，然后尝试执行当前任务DiscardOldestPolicy、不动声色的丢弃并且不抛异常DiscardPolicy。项目中如果为了更多的用户体验，可以自定义拒绝策略。

**threadFactory**：创建线程的工厂，虽说JDK提供了线程工厂的默认实现DefaultThreadFactory，但还是建议自定义实现最好，这样可以自定义线程创建的过程，例如线程分组、自定义线程名称等。

#### CPU密集型 ####

> 获得cpu的核数，不同的硬件不一样,设置核数的的线程数量。

> 我们可以通过代码Runtime.getRuntime().availableProcessors();获取，然后设置。

#### IO密集型 ####

> IO非常消耗资源，所有我们需要计算大型的IO程序任务有多少个。

> 一般来说，线程池最大值 >  
> 大型任务的数量即可

> 一般设置大型任务的数量\*2

线程池大小= 最大线程数 + 阻塞队列大小

LinkedBlockingQueue给put(放入元素),take(取元素)都声明了一把锁，放入和取互不影响，效率更高。

ArrayBlockingQueue 使用数组实现，在声明的时候必须指定长度，如果长度太大，造成内存浪费，长度太小，并发性能不高，如果数组满了，就无法放入元素，除非有其他线程取出元素，放入和取出都使用同一把锁，因此存在竞争，效率比LinkedBlockingQueue低

#### 四种策略 ####

> 1、AbortPolicy（被拒绝了抛出异常）
> 
> 2、CallerRunsPolicy(使用调用者所在线程执行，就是哪里来的回哪里去)
> 
> 3、DiscardOldestPolicy(尝试去竞争第一个，失败了也不抛异常)
> 
> 4、DiscardPolicy(默默丢弃、不抛异常)

#### 拒绝策略执行则么办？ ####

1、另外创建一个队列,当拒绝策略执行将任务放入队列。

通过定时任务去每隔一秒去查看线程池队列中是否有任务,没有则添加进去。

缺点: 任务会丢失,线程优雅关闭是指正常情况队列执行晚。会关闭。如果用这种方法创建则会丢失任务。

2、如果 是特别重要的话就 放入DB去持久化,给任务加个状态,通过状态来判断任务的执行情况。

3、其他情况要根据场景考虑 比如又些任务过期淘汰

#### 线程池五种状态 ####

> 1.  Running 接受新任务以及执行任务
> 2.  shutdown 拒绝新的任务以及处理以有的任务
> 3.  stop 停止正在执行的任务
> 4.  tidying 记录线程数量以及运行状态
> 5.  terminated彻底终止线程执行

#### 线程池工作原理 ####

1.通过execute方法提交任务时，当线程池中的线程数小于corePoolSize时，新提交的任务将通过创建一个新线程来执行，即使此时线程池中存在空闲线程。

![2c13148b153943799ee7e0d49938872f.png][]

2.通过execute方法提交任务时，当线程池中线程数量达到corePoolSize时，新提交的任务将被放入workQueue中，等待线程池中线程调度执行。

![7d865ce72c814a66a0bbbd4543a55647.png][]

3.通过execute方法提交任务时，当workQueue已存满，且maximumPoolSize大于corePoolSize时，新提交的任务将通过创建新线程执行。

![dd6ea06c478e44aabd5ec0072f2d5140.png][]

4.当线程池中的线程执行完任务空闲时，会尝试从workQueue中取头结点任务执行。

![1b564e02adb54e398a310850e7edffe1.png][]

5.通过execute方法提交任务，当线程池中线程数达到maxmumPoolSize，并且workQueue也存满时，新提交的任务由RejectedExecutionHandler执行拒绝操作。

![88f9825d71f84dbeaa84bdebb8d4bca3.png][]

6.当线程池中线程数超过corePoolSize，并且未配置allowCoreThreadTimeOut=true，空闲时间超过keepAliveTime的线程会被销毁，保持线程池中线程数为corePoolSize。

![a6077dfc9eff47ab88f6043df9ac0484.png][]

注意：上图表达的是销毁空闲线程，保持线程数为corePoolSize，不是销毁corePoolSize中的线程。

7.当设置allowCoreThreadTimeOut=true时，任何空闲时间超过keepAliveTime的线程都会被销毁。

![a556777d658149e39139865708f90ce5.png][]

执行流程

![35ec577c8971480eaf940ecaa8053897.png][]

[18525bc13b1342d1bc46c7fa9b867867.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/afbe4fbb6dfa4eadb632d6e8addc47ec.png
[2c13148b153943799ee7e0d49938872f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/47ff9661ed6d4e74807834b73d445fe3.png
[7d865ce72c814a66a0bbbd4543a55647.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9fbdb8d4712e45f7ad3a4e883c07bfeb.png
[dd6ea06c478e44aabd5ec0072f2d5140.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ff993bd4a42e4a89b61cd0a944b5bf1c.png
[1b564e02adb54e398a310850e7edffe1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0778b9fc0e7a42afa08f89dc7334ec43.png
[88f9825d71f84dbeaa84bdebb8d4bca3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/599faf97375643218ca22fc858d0afc7.png
[a6077dfc9eff47ab88f6043df9ac0484.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c60b074abaeb4e1c9a97cf94a3a64e52.png
[a556777d658149e39139865708f90ce5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0cffe1729f9e4daf88aa9d78e205d86e.png
[35ec577c8971480eaf940ecaa8053897.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5df3e8355df346a89f955d830304ed88.png