【Java并发编程】之线程池

以你之姓@ 2023-02-23 05:09 139阅读 0赞

### *为什么要用线程池？* ###

**池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。**

**线程池**提供了一种限制和管理资源（包括执行一个任务）。每个**线程池**还维护一些基本统计信息，例如已完成任务的数量。

这里借用《Java 并发编程的艺术》提到的来说一下**使用线程池的好处**：

*  **降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
 *  **提高响应速度**。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
 *  **提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

### *实现Runnable接口和Callable接口的区别* ###

`Runnable`自Java 1.0以来一直存在，但`Callable`仅在Java 1.5中引入,目的就是为了来处理`Runnable`不支持的用例。**`Runnable` 接口**不会返回结果或抛出检查异常，但是\*\*`Callable` 接口\*\*可以。所以，如果任务不需要返回结果或抛出异常推荐使用 **`Runnable` 接口**，这样代码看起来会更加简洁。

工具类 `Executors` 可以实现 `Runnable` 对象和 `Callable` 对象之间的相互转换。（`Executors.callable（Runnable task`）或 `Executors.callable（Runnable task，Object resule）`）。

### *执行execute()方法和submit()方法的区别是什么？* ###

1.  **`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；**
2.  **`submit()`方法用于提交需要返回值的任务。线程池会返回一个 `Future` 类型的对象，通过这个 `Future` 对象可以判断任务是否执行成功**，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

我们以\*\*`AbstractExecutorService`\*\*接口中的一个 `submit` 方法为例子来看看源代码：

public Future<?> submit(Runnable task) { 
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

上面方法调用的 `newTaskFor` 方法返回了一个 `FutureTask` 对象：

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { 
        return new FutureTask<T>(runnable, value);
    }

我们再来看看`execute()`方法：

public void execute(Runnable command) { 
    	...
    }

### *如何创建线程池* ###

《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

Executors 返回线程池对象的弊端如下：

*  **FixedThreadPool 和 SingleThreadExecutor** ：允许请求的队列长度为 Integer.MAX\_VALUE ，可能堆积大量的请求，从而导致OOM（内存溢出）
 *  **CachedThreadPool 和 ScheduledThreadPool** ：允许创建的线程数量为 Integer.MAX\_VALUE ，可能会创建大量线程，从而导致OOM（内存溢出）

**方式一：通过构造方法实现**

public ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>)
    public ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, ThreadFactory)
    public ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, RejectedExecutionHandler)
    public ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, ThreadFactory, RejectedExecutionHandler)

**方式二：通过Executor 框架的工具类Executors来实现**我们可以创建三种类型的ThreadPoolExecutor：

*  **FixedThreadPool** ：该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
 *  **SingleThreadExecutor：** 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
 *  **CachedThreadPool：** 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

这三个工具类方法内部实际上是调用了 ThreadPoolExecutor 的构造方法。

### *ThreadPoolExecutor 类分析* ###

`ThreadPoolExecutor` 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么），比较简单：

/** * 用给定的初始参数创建一个新的ThreadPoolExecutor。 */
    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

### *ThreadPoolExecutor\`构造函数重要参数分析* ###

**`ThreadPoolExecutor` 3 个最重要的参数：**

*  **`corePoolSize` :** 核心线程数线程数定义了最小可以同时运行的线程数量。
 *  **`maximumPoolSize` :** 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
 *  **`workQueue`:** 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，信任就会被存放在队列中

`ThreadPoolExecutor`其他常见参数:

*  **`keepAliveTime`**:当线程池中的线程数量大于 `corePoolSize` 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 `keepAliveTime`才会被回收销毁；
 *  **`unit`** : `keepAliveTime` 参数的时间单位。
 *  **`threadFactory`** :executor 创建新线程的时候会用到。
 *  **`handler`** :饱和策略。

### *ThreadPoolExecutor 饱和策略* ###

**`ThreadPoolExecutor` 饱和策略定义:**

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任时，`ThreadPoolTaskExecutor` 定义一些策略:

*  **`ThreadPoolExecutor.AbortPolicy`**：抛出 `RejectedExecutionException`来拒绝新任务的处理。
 *  **`hreadPoolExecutor.CallerRunsPolicy`**：调用执行自己的线程运行任务。但不会任务请求。但是这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略
 *  **`ThreadPoolExecutor.DiscardPolicy`：** 不处理新任务，直接丢弃掉。
 *  **`ThreadPoolExecutor.DiscardOldestPolicy`：** 此策略将丢弃最早的未处理的任务请求。

举个例子：Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候，当我们不指定 `RejectedExecutionHandler` 饱和策略的话来配置线程池的时候默认使用的是 `ThreadPoolExecutor.AbortPolicy`。在默认情况下，`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。对于可伸缩的应用程序，建议使用 `ThreadPoolExecutor.CallerRunsPolicy`。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 `ThreadPoolExecutor` 的构造函数源码就可以看出，比较简单的原因）

### *一个简单的线程池例子: `Runnable`\+`ThreadPoolExecutor`* ###

首先创建一个 `Runnable` 接口的实现类（当然也可以是 `Callable` 接口）：

/** * 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。 */
    public class MyRunnable implements Runnable { 
    
        private String command;
    
        public MyRunnable(String s) { 
            this.command = s;
        }
    
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
            processCommand();
            System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
        }
    
        private void processCommand() { 
            try { 
                Thread.sleep(5000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        @Override
        public String toString() { 
            return this.command;
        }
    }

编写测试程序，我们这里以阿里巴巴推荐的使用 `ThreadPoolExecutor` 构造函数自定义参数的方式来创建线程池：

public class ThreadPoolExecutorDemo { 
    
        private static final int CORE_POOL_SIZE = 5;
        private static final int MAX_POOL_SIZE = 10;
        private static final int QUEUE_CAPACITY = 100;
        private static final Long KEEP_ALIVE_TIME = 1L;
        public static void main(String[] args) { 
    
            //使用阿里巴巴推荐的创建线程池的方式
            //通过ThreadPoolExecutor构造函数自定义参数创建
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                    CORE_POOL_SIZE,
                    MAX_POOL_SIZE,
                    KEEP_ALIVE_TIME,
                    TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                    new ThreadPoolExecutor.CallerRunsPolicy());
    
            for (int i = 0; i < 10; i++) { 
                //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
                Runnable worker = new MyRunnable("" + i);
                //执行Runnable
                executor.execute(worker);
            }
            //终止线程池
            executor.shutdown();
            while (!executor.isTerminated()) { 
            }
            System.out.println("Finished all threads");
        }
    }
    
    OutPut >>>>>
    pool-1-thread-2 Start. Time = Tue Nov 12 20:59:44 CST 2019
    pool-1-thread-5 Start. Time = Tue Nov 12 20:59:44 CST 2019
    pool-1-thread-4 Start. Time = Tue Nov 12 20:59:44 CST 2019
    pool-1-thread-1 Start. Time = Tue Nov 12 20:59:44 CST 2019
    pool-1-thread-3 Start. Time = Tue Nov 12 20:59:44 CST 2019
    pool-1-thread-5 End. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-3 End. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-2 End. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-4 End. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-1 End. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-2 Start. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-1 Start. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-4 Start. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-3 Start. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-5 Start. Time = Tue Nov 12 20:59:49 CST 2019
    pool-1-thread-2 End. Time = Tue Nov 12 20:59:54 CST 2019
    pool-1-thread-3 End. Time = Tue Nov 12 20:59:54 CST 2019
    pool-1-thread-4 End. Time = Tue Nov 12 20:59:54 CST 2019
    pool-1-thread-5 End. Time = Tue Nov 12 20:59:54 CST 2019
    pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019

可以看到我们上面的代码指定了：

1.  `corePoolSize`: 核心线程数为 5
2.  `maximumPoolSize` ：最大线程数 10
3.  `keepAliveTime` : 等待时间为 1L
4.  `unit`: 等待时间的单位为 TimeUnit.SECONDS
5.  `workQueue`：任务队列为 `ArrayBlockingQueue`，并且容量为 100
6.  `handler`:饱和策略为 `CallerRunsPolicy`

### *线程池原理分析* ###

通过上面的代码输出结果可以看出：**线程池每次会同时执行 5 个任务，这 5 个任务执行完之后，剩余的 5 个任务才会被执行。**

现在，我们就分析上面的输出内容来简单分析一下线程池原理。

\*\*为了搞懂线程池的原理，我们需要首先分析一下 `execute`方法。\*\*在 例子中的 Demo 中我们使用 `executor.execute(worker)`来提交一个任务到线程池中去，这个方法非常重要，下面我们来看看它的源码：

// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    
    private static int workerCountOf(int c) { 
        return c & CAPACITY;
    }
    
    private final BlockingQueue<Runnable> workQueue;
    
    public void execute(Runnable command) { 
        // 如果任务为null，则抛出异常。
        if (command == null)
            throw new NullPointerException();
        // ctl 中保存的线程池当前的一些状态信息
        int c = ctl.get();
    
        // 下面会涉及到 3 步 操作
        // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
        // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        if (workerCountOf(c) < corePoolSize) { 
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
        // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
        if (isRunning(c) && workQueue.offer(command)) { 
            int recheck = ctl.get();
            // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
            if (!isRunning(recheck) && remove(command))
                reject(command);
            // 如果当前线程池为空就新创建一个线程并执行。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
        else if (!addWorker(command, false))
            reject(command);
    }

我们可以把原理总结为下面这个图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Fpd2FuZ3Rpbmd5dW4_size_16_color_FFFFFF_t_70_pic_center]

现在应该很容易就可以搞懂它的原理了吧！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Fpd2FuZ3Rpbmd5dW4_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200705152834821.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Fpd2FuZ3Rpbmd5dW4=,size_16,color_FFFFFF,t_70#pic_center