线程池核心原理

标签：核心任务线程 taskId 创建原理执行 ThreadPoolExecutor

文章目录

线程池核心原理
ThreadPoolExecutor
Executor框架
线程池实战

线程池的核心原理是基于“池化”（Pooling）思想，这种思想在计算机科学中广泛应用，例如数据库连接池、对象池等。线程池的主要目的是为了减少线程创建和销毁的开销，提高线程的复用性，从而提高程序的性能和响应速度。以下是线程池的核心原理：

线程复用：线程池中维护了一组工作线程（Worker Threads），这些线程被创建后不会立即销毁，而是用于执行多个任务。当任务到达时，线程池会从池中选出一个空闲的线程来执行任务，而不是每次都创建新线程。
任务队列：线程池通常配备了一个任务队列（Work Queue），用于存储待执行的任务。当所有工作线程都处于忙碌状态时，新提交的任务会被放入队列中等待空闲线程。
线程管理：线程池内部会管理线程的生命周期，包括线程的创建、销毁、工作线程的数量等。线程池会根据配置的核心线程数（Core Pool Size）和最大线程数（Maximum Pool Size）来控制线程的数量。
任务分配：线程池中的任务分配器（Task Scheduler）负责从任务队列中取出任务，并将任务分配给空闲的工作线程。
动态线程管理：线程池可以根据当前负载动态地调整线程数量。例如，当任务队列满了，并且所有核心线程都处于忙碌状态时，线程池可能会创建新的线程，直到达到最大线程数。
拒绝策略：当线程池达到最大线程数，并且任务队列已满时，线程池会根据预定义的拒绝策略来处理新提交的任务。常见的拒绝策略包括抛出异常、直接丢弃任务、丢弃队列中最老的任务等。

ThreadPoolExecutor

ThreadPoolExecutor 是 Java 中线程池的核心实现，位于 java.util.concurrent 包下。它提供了线程池的基本功能，包括线程的创建、任务的执行、线程的回收等，并允许开发者自定义线程池的行为。

主要构造函数：

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

corePoolSize：核心线程数，即始终存在的线程数量。
maximumPoolSize：最大线程数，即线程池中允许的最大线程数量。
keepAliveTime：非核心线程的空闲存活时间。
unit：keepAliveTime 的时间单位。
workQueue：用于存放任务的阻塞队列。
threadFactory：线程工厂，用于创建新线程。
handler：拒绝策略，用于处理当线程池和队列都满时新提交的任务。

执行任务：

ThreadPoolExecutor 提供了多个方法来执行任务：

execute(Runnable command)：执行一个 Runnable 任务。
submit(Runnable task)：提交一个 Runnable 任务，并返回一个 Future 对象，可以通过这个对象获取任务执行的结果（如果有）。
submit(Callable task)：提交一个 Callable 任务，并返回一个 Future 对象，可以通过这个对象获取任务执行的结果。

关闭线程池：

ThreadPoolExecutor 可以通过以下方法来关闭：

shutdown()：启动线程池的关闭序列，不再接受新任务，但会继续执行所有已经提交的任务。
shutdownNow()：尝试立即停止所有正在执行的任务，并返回尚未开始执行的任务列表。

线程池生命周期：

ThreadPoolExecutor 定义了线程池的生命周期状态，包括：

RUNNING：接受新任务并处理队列中的任务。
SHUTDOWN：不接受新任务，但处理队列中的任务。
STOP：不接受新任务，不处理队列中的任务，并尝试中断正在执行的任务。
TIDYING：所有任务都已终止，线程池正在转换为 TERMINATED 状态。
TERMINATED：线程池已终止。

Executor框架

Executor框架是Java 5引入的一个用于并发编程的框架，它提供了任务执行和异步任务管理的工具。这个框架的主要目的是简化线程的使用和管理，使得开发者可以更加专注于任务的逻辑，而不是线程的创建和管理。Executor框架的主要组件包括：

Executor接口：

这是框架的基础，一个简单的接口，定义了执行任务的方法 execute(Runnable command)。

ExecutorService接口：

继承自Executor接口，提供了更多管理任务执行的方法，如 submit()、shutdown()、shutdownNow() 等。
它还提供了用于批量执行任务的方法，如 invokeAll() 和 invokeAny()。

ThreadPoolExecutor类：

ExecutorService接口的一个实现，是一个灵活的线程池实现，允许开发者自定义线程池的参数和行为。

ScheduledExecutorService接口：

继承自ExecutorService，提供了定时任务执行的方法，如 schedule()、scheduleAtFixedRate()、scheduleWithFixedDelay()。

ScheduledThreadPoolExecutor类：

ScheduledExecutorService接口的一个实现，用于执行定时任务和周期性任务。

Future接口：

表示异步计算的结果，提供了检查计算是否完成、等待计算完成、获取计算结果、取消计算等方法。

Callable接口：

与Runnable类似，但它允许任务返回一个结果或抛出一个异常。

Executor框架的使用通常涉及以下步骤：

创建ExecutorService实例，例如通过ThreadPoolExecutor或Executors工厂类。
提交Runnable或Callable任务到ExecutorService。
使用Future来获取任务的结果（如果任务提交时使用了submit()方法）。
关闭ExecutorService，防止新任务的提交，并等待所有任务执行完成。

线程池实战

使用线程池的实战通常涉及到java.util.concurrent包中的ExecutorService和ThreadPoolExecutor类。以下是一个简单的示例，展示了如何使用线程池来执行多个任务。

步骤1：创建线程池

首先，我们需要创建一个线程池。我们可以使用Executors工厂类来创建一个固定大小的线程池，也可以直接使用ThreadPoolExecutor构造函数来定制线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 创建一个固定大小的线程池，包含5个线程
ExecutorService executorService = Executors.newFixedThreadPool(5);

步骤2：创建任务

接下来，我们创建一个实现Runnable接口的任务类。

import java.util.concurrent.TimeUnit;

public class MyTask implements Runnable {
    private final int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("开始执行任务：" + taskId);
        try {
            // 模拟任务执行需要一段时间
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务：" + taskId + " 执行完成");
    }
}

步骤3：提交任务到线程池

现在我们可以将任务提交到线程池中执行。

for (int i = 0; i < 10; i++) {
    executorService.submit(new MyTask(i));
}

步骤4：关闭线程池

最后，当我们不再需要线程池时，应该关闭它以释放资源。

executorService.shutdown();

完整示例

将上述步骤组合在一起，我们得到一个完整的线程池使用示例。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，包含5个线程
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            executorService.submit(new MyTask(i));
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

class MyTask implements Runnable {
    private final int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("开始执行任务：" + taskId);
        try {
            // 模拟任务执行需要一段时间
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务：" + taskId + " 执行完成");
    }
}

我们创建了一个包含5个线程的线程池，并提交了10个任务。由于线程池的大小限制，一次只能执行5个任务，其他任务会在队列中等待。每个任务模拟执行2秒，然后输出完成信息。
在实际应用中，线程池的使用会更加复杂，可能需要根据应用程序的特定需求来调整线程池的大小和配置，以及处理任务执行中的异常和结果。

标签：核心,任务,线程,taskId,创建,原理,执行,ThreadPoolExecutor
From： https://blog.csdn.net/m0_68933188/article/details/137224451

线程池核心原理

文章目录