Java进阶篇--Executors类创建常见线程池

已于 2023-11-07 13:31:24 修改
阅读量214 收藏 1
点赞数 3
分类专栏： Java进阶篇 文章标签： java 开发语言 学习 后端
于 2023-11-07 12:05:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74293254/article/details/134263065
版权

目录

线程池架构 

newSingleThreadExecutor

newFixedThreadPool

newCachedThreadPool

newScheduledThreadPool

Executors和ThreaPoolExecutor创建线程池的区别

两种提交任务的方法

线程池架构 

线程池是一种线程管理的机制，用于维护和复用线程，以减少线程创建和销毁的开销。

在Java中，线程池的顶级接口是Executor，而真正的线程池接口是ExecutorService。以下是一些重要的类和接口：

  1. ExecutorService：真正的线程池接口，提供了执行、管理和控制任务的方法。

  2. ScheduledExecutorService：继承自ExecutorService，能够解决那些需要任务重复执行的问题，支持定时和周期性任务执行。

  3. ThreadPoolExecutor：ExecutorService的默认实现，提供了丰富的配置选项，如核心线程数、最大线程数、工作队列类型等。

  4. ScheduledThreadPoolExecutor：继承自ThreadPoolExecutor的ScheduledExecutorService接口实现，用于周期性任务调度。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

在Java中，可以通过Executors工厂类提供四种常见类型的线程池：

  1. newCachedThreadPool：创建一个可缓存线程池，适用于执行大量短期异步任务的场景，线程数量不受限制，可以灵活回收空闲线程。

  2. newFixedThreadPool：创建一个固定大小的线程池，适用于控制最大并发数的场景，超出的任务会在队列中等待。

  3. newScheduledThreadPool：创建一个定时线程池，用于支持定时及周期性任务执行的场景。

  4. newSingleThreadExecutor：创建一个单线程化的线程池，用于保证所有任务按照指定顺序执行的场景，只会使用唯一的工作线程来执行任务。

通过选择合适的线程池类型，并根据实际需求进行配置，可以有效管理和优化多线程任务的执行。

newSingleThreadExecutor

newSingleThreadExecutor 是 Executors 工厂类提供的一种线程池，它创建的是单线程化的线程池。具体来说，newSingleThreadExecutor 只会使用单个工作线程来执行任务，保证所有任务按照指定顺序（如 FIFO、LIFO、优先级）依次执行。

这种线程池适用于以下场景：

1. 顺序执行：需要按照特定顺序执行任务，避免并发引起的竞争条件或数据一致性问题。

2. 确保任务不被并发执行：有些任务可能不支持并发执行，此时可以使用单线程化的线程池来保证任务的顺序执行。

3. 上下文切换开销较大的任务：对于一些上下文切换开销较大的任务，如果采用并发执行可能带来额外的开销，可以选择单线程化的线程池来避免这种情况。

在单线程化的线程池中，任务会按照提交的顺序依次执行，不会存在并发执行的情况。如果某个任务由于异常结束，后续的任务会继续执行，不会受到影响。

以下是一个简单的 Java 代码示例，演示了如何使用 newSingleThreadExecutor 创建单线程化的线程池，并提交任务执行：

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

public class main {
    public static void main(String[] args) {
        // 创建一个单线程化的线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交多个任务给线程池执行
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 正在线程上运行： " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 保持中断状态
                }
            });
        }

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

在上面的示例中，我们首先通过 Executors.newSingleThreadExecutor() 方法创建了一个单线程化的线程池。然后，使用 executor.submit() 方法向线程池提交了5个任务，每个任务都会打印当前线程名并模拟执行一段时间。最后，通过 executor.shutdown() 关闭了线程池。 

需要注意的是，虽然该线程池只使用单个工作线程来执行任务，但仍然可以通过 ExecutorService 提供的方法提交多个任务，这些任务会按照提交的顺序被放入队列，并由单个工作线程逐个执行。

总之，SingleThreadExecutor 用于串行执行任务的场景，每个任务必须按顺序执行，不需要并发执行。

newFixedThreadPool

newFixedThreadPool 是 Executors 工厂类提供的一种固定大小的线程池，它创建的线程池具有固定数量的工作线程。具体来说，newFixedThreadPool 创建的线程池会维护一个固定数量的工作线程，当有任务提交时，会使用其中一个工作线程来执行任务。

这种线程池适用于以下场景：

  1. 控制最大并发数：需要限制并发执行的任务数量，以防止系统资源被过度占用。

  2. 资源限制：对于一些资源受限的场景，如数据库连接池、网络连接池等，可以使用固定大小的线程池来控制资源的分配和利用。

  3. 预测性能需求：在已知任务量和性能需求的情况下，可以根据需求预先配置固定数量的工作线程，以保证系统在高负载时仍能稳定运行。

在固定大小的线程池中，线程的数量是固定的，不会根据任务的增加或减少而自动调整。如果所有工作线程都正在执行任务，并且有新任务提交时，新任务会被放入队列中等待，直到有工作线程空闲出来才会被执行。

以下是一个简单的 Java 代码示例，演示了如何使用 newFixedThreadPool 创建固定大小的线程池，并提交任务执行：

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

public class main {
    public static void main(String[] args) {
        // 创建一个固定大小为3的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交多个任务给线程池执行
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 正在线程上运行: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 保持中断状态
                }
            });
        }

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

在上面的示例中，我们通过 Executors.newFixedThreadPool(3) 方法创建了一个固定大小为3的线程池。然后，使用 executor.submit() 方法向线程池提交了5个任务，每个任务都会打印当前线程名并模拟执行一段时间。最后，通过 executor.shutdown() 关闭了线程池。

当你运行这段代码时，你会看到虽然提交了5个任务，但是只有3个任务会同时在不同的工作线程中执行，因为线程池的大小被限制为3。剩余的任务会在有线程空闲时依次执行。

需要注意的是，在使用固定大小的线程池时，应该根据系统资源和运行环境合理地配置线程数量，避免资源浪费或不足的情况发生。

总之，FixedThreadPool 用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。

newCachedThreadPool

newCachedThreadPool 是 Executors 工厂类提供的一种可缓存线程池，它创建的线程池会根据需要自动调整线程数量。具体来说，当有新任务提交时，如果当前有空闲线程，则会立即使用空闲线程执行任务；如果没有空闲线程，则会创建新的线程来处理任务。而对于长时间闲置未被使用的线程，它们会在一定的空闲时间后被回收，从而使得线程池的大小能够动态调整。

这种线程池适用于以下场景：

  1. 处理大量短时耗任务：适用于有大量短时耗的任务需要处理的情况，例如网络请求响应、小数据处理等。

  2. 并发需求不确定：当并发需求不确定，且系统资源充足时，可以使用可缓存线程池来动态调整线程数量，以适应不同负载情况。

  3. 短期高并发：对于突发性的高并发情况，可缓存线程池能够快速创建新线程来应对，从而保证任务的及时处理。

以下是一个简单的 Java 代码示例，演示了如何使用 newCachedThreadPool 创建可缓存线程池，并提交任务执行：

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

public class main {
    public static void main(String[] args) {
        // 创建一个可缓存线程池
        ExecutorService executor = Executors.newCachedThreadPool();

        // 提交多个任务给线程池执行
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + "正在线程上运行： " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 保持中断状态
                }
            });
        }

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

在上面的示例中，我们通过 Executors.newCachedThreadPool() 方法创建了一个可缓存线程池。然后，使用 executor.submit() 方法向线程池提交了5个任务，每个任务都会打印当前线程名并模拟执行一段时间。最后，通过 executor.shutdown() 关闭了线程池。

当你运行这段代码时，你会看到所有5个任务都会立即在不同的工作线程中执行，因为可缓存线程池会根据需要动态调整线程数量。这种机制能够很好地适应不同负载情况下的任务处理需求。

需要注意的是，由于可缓存线程池的特性是动态调整线程数量，因此在任务提交过多导致线程数激增时，需要谨慎控制以避免资源耗尽的情况发生。

总之，CachedThreadPool 用于并发执行大量短期的小任务，或者是负载较轻的服务器。

newScheduledThreadPool

newScheduledThreadPool 是 Executors 工厂类提供的一种创建定时任务的线程池。它创建的线程池可以执行延迟任务和周期性任务，它会在给定的延迟时间后执行任务，或者定期执行任务。这种线程池适用于需要执行定时任务或者周期性任务的场景。

具体来说，newScheduledThreadPool 创建的线程池有以下特点：

  1. 支持延迟任务执行：可以使用 schedule() 方法提交一个任务，并指定延迟时间，线程池会在延迟时间过去后执行相应的任务。
  2. 支持周期性任务执行：可以使用 scheduleAtFixedRate() 或者 scheduleWithFixedDelay() 方法提交一个任务，并指定初始延迟时间和执行间隔，线程池会按照指定的间隔周期性执行任务。
  3. 灵活控制：可以通过 ScheduledExecutorService 提供的方法对定时任务进行取消、查询等操作，非常灵活方便。

在实际应用中，newScheduledThreadPool 可以用于定时数据同步、定时任务触发、定时器等场景，能够很好地满足对任务执行时间有特定要求的需求。

下面是一个简单的 Java 代码示例，演示了如何使用 newScheduledThreadPool 创建定时任务的线程池，并提交延迟任务和周期性任务：

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

public class main {
    public static void main(String[] args) {
        // 创建一个定时任务线程池
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

        // 提交延迟任务
        executor.schedule(() -> System.out.println("延迟的任务"), 2, TimeUnit.SECONDS);

        // 提交周期性任务
        executor.scheduleAtFixedRate(() -> System.out.println("周期性任务"), 0, 1, TimeUnit.SECONDS);

        // 等待一段时间后关闭线程池
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        executor.shutdown();
    }
}

在上面的示例中，我们通过 Executors.newScheduledThreadPool(1) 方法创建了一个定时任务线程池。然后，使用 schedule() 方法提交了一个延迟任务，在2秒后执行；同时使用 scheduleAtFixedRate() 方法提交了一个周期性任务，每隔1秒执行一次。最后，我们等待一段时间后关闭了线程池。

当你运行这段代码时，你会看到延迟任务和周期性任务会按照预定的时间被执行。这展示了 newScheduledThreadPool 的定时任务执行能力。

总之，ScheduledThreadPoolExecutor 用于需要多个后台线程执行周期任务，同时需要限制线程数量的场景。

Executors和ThreaPoolExecutor创建线程池的区别

在 Java 中，确实存在着 Executors 工厂类的几种创建线程池的方法存在一些缺陷，让我们来具体分析一下。

1、newFixedThreadPool 和 newSingleThreadExecutor：

这两种方法都使用了无界的 LinkedBlockingQueue 作为工作队列，在任务提交速度持续大于任务处理速度的情况下，可能会导致队列中累积大量的任务，从而消耗大量内存。如果任务量非常大或者任务执行时间非常长，那么这种设计就会面临 OutOfMemoryError （简称：OOM）的风险。

2、newCachedThreadPool 和 newScheduledThreadPool：

这两种方法在某些情况下可能会创建大量的线程，因为它们的最大线程数是 Integer.MAX_VALUE。如果系统负载突然增加，那么就可能创建非常多的线程，从而消耗大量系统资源，甚至导致 OutOfMemoryError（简称：OOM）。

而相较之下，使用 ThreadPoolExecutor 构造函数创建线程池可以更好地控制线程池的行为，避免上述问题。通过 ThreadPoolExecutor 的构造函数，可以显式地指定核心线程数、最大线程数、工作队列类型、拒绝策略等参数，从而更精细地控制线程池的行为。

因此，在开发中，建议根据具体需求和系统负载情况，选择合适的线程池创建方法，并结合 ThreadPoolExecutor 来进行更为细致的参数配置，以避免潜在的问题。

两种提交任务的方法

ExecutorService 提供了两种提交任务的方法：

1、execute(Runnable command)：

这个方法用于提交不需要返回值的任务。它接受一个 Runnable 对象作为参数，表示要执行的任务，但并不关心任务的返回结果。

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.execute(new RunnableTask());

2、submit(Callable<T> task)：

这个方法用于提交需要返回值的任务。它接受一个 Callable 对象作为参数，表示要执行的任务，并返回一个 Future 对象，通过它可以获取任务执行的结果。

ExecutorService executor = Executors.newFixedThreadPool(10);
Future<String> future = executor.submit(new CallableTask());
String result = future.get(); // 获取任务执行结果

通过这两种方法，可以灵活地提交不同类型的任务，并根据需要获取它们的执行结果。execute 方法适用于 fire-and-forget 的场景，而 submit 方法则更适合需要获取任务执行结果的情况。

以下是使用 ExecutorService 提供的 execute 和 submit 方法的示例代码：

import java.util.concurrent.*;

public class main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 创建一个固定大小为 3 的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交第一个任务
        Future<Integer> future1 = executor.submit(() -> {
            System.out.println("任务1正在运行");
            return 42;
        });

        // 提交第二个任务，并依赖于第一个任务的结果
        Future<Integer> future2 = executor.submit(() -> {
            int result = future1.get(); // 等待第一个任务的执行结果
            System.out.println("任务2正在根据任务1的结果运行： " + result);
            return result * 2;
        });

        // 提交第三个任务，并依赖于第二个任务的结果
        executor.execute(() -> {
            try {
                int result = future2.get(); // 等待第二个任务的执行结果
                System.out.println("任务3正在根据任务2的结果运行：" + result);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });

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

在这个示例中，我们使用submit方法提交了第一个和第二个任务，并使用execute方法提交了第三个任务。第二个任务依赖于第一个任务的结果，而第三个任务则依赖于第二个任务的结果。通过这种方式，我们展示了如何在复杂情况下使用ExecutorService的execute和submit方法来提交具有相互依赖关系的任务。

程序员老李头
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多线程基础（九）Executors线程池
m0_47743175的博客
06-18 1589
Executors线程池
Java并发多线程编程——Executors类
小志的博客
06-16 1393
一、Executors的理解 Executors类属于java.util.concurrent包； 线程池的创建分为两种方式：ThreadPoolExecutor 和 Executors； Executors（静态Executor工厂）用于创建线程池； 工厂和工具方法Executor ， ExecutorService ， ScheduledExecutorService ， ThreadFactory和Callable在此包中定义的类； jdk1.8API中的解释如下: 二、Executors常用的
java多线程——线程池概述及Executors常用方法
最新发布
快乐学习，daydayup!
03-31 272
java多线程——线程池概述及Executors常用方法
线程池
斜月&三星
12-06 276
1.线程池的定义 管理一组工作线程。通过线程池复用线程有以下几点优点： 减少资源创建 => 减少内存开销，创建线程占用内存。 降低系统开销 => 创建线程需要时间，会延迟处理的请求。 提高稳定稳定性 => 避免无限创建线程引起的OutOfMemoryError【简称OOM】。 2.Executors创建线程池的方式 根据返回...
史上最全的java线程池解析
it_manman的博客
12-19 494
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool...
Java线程池——Executor框架
qq_25046827的博客
11-11 859
这个类适当地扩展了AbstractQueuedSynchronizer，以简化获取和释放围绕每个任务执行的锁。这可以防止中断，这些中断旨在唤醒等待任务的工作线程，而不是中断正在运行的任务。我们实现了一个简单的不可重入互斥锁，而不是使用ReentrantLock，因为我们不希望工作任务在调用setCorePoolSize等池控制方法时能够重新获得锁。此外，为了在线程实际开始运行任务之前抑制中断，我们将锁状态初始化为负值，并在启动时(在runWorker中)清除它。
Java中Executors类中几种创建各类型线程池
01-03
Java中Executors类中几种创建各类型线程池方法及简单实例
Java并发编程中使用Executors类创建和管理线程的用法
09-02
主要介绍了Java并发编程中使用Executors类创建和管理线程的用法,文中举了用其启动线程和设置线程优先级的例子,需要的朋友可以参考下
Java并发编程中使用Executors类创建和管理线程的
10-30
Java并发编程中使用Executors类创建和管理线程的用法共4页.pdf.zip
Java多线程Executors批量执行数据实现限流
05-20
java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。 2.数据批量导出。 3任务数据异步执行。 4.多线程...
线程-线程池-锁-集合-Map-队列.docx
05-18
线程是系统中可执行调度的...线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，规避资源耗尽的风险。集合的详细描述，以及集合中的异同点，HashMap不同jdk版本区别，ConcurrentHashMap介绍。
Java ~ Executor【总结】
说淑人的所思所想
02-20 626
Executor（执行器）接口是执行器框架的最顶级接口，定义了执行器的概念，并明确了该框架的核心目标：将任务的递交与执行分离（并负责执行）。 执行器接口并不严格（推荐但不强制）要求任务的执行是异步的。 执行器接口虽然在执行器框架中的拥有最高的地位，但由于其功能过于单一，因此在实际开发中往往会使用其子接口ExecutorService（执行器服务）代替。
一文带你了解Java线程池(Executor)-上
m0_68103752的博客
04-06 1576
分析Java线程池就离不开Executor类，今天就让我们来一起好好看下 Executor框架 为了更好地控制多线程，JDK提供了一套Executor框架，可以有效地进行线程控制，其本质上就是一个线程池。 其中ThreadPoolExecutor表示一个线程池。Executors类则扮演着线程池工厂的角色，通过Executors可以取得一个拥有特定功能的线程池。从上图可知，ThreadPoolExecutor类实现了Executor接口，因此，通过这个接口，任何Runnable对象都可以被Th
Java中的工具类Executors详解
白话机器学习
08-17 410
如果没有可用的线程，则创建一个新线程并添加到池中。从上图中也可以看出，Executors的创建线程池的方法，创建出来的线程池都实现了ExecutorService接口。就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。其实，在上面的报错信息中，我们是可以看出蛛丝马迹的，在以上的代码中其实已经说了，真正的导致OOM的其实是。是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为。
Java并发编程：第四章 线程池（Executor框架）
玉汝于成
03-20 1304
Executors 是 Java 并发包 java.util.concurrent 中的一个工具类，它提供了一组用于创建线程池的方法。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的 ThreadFactory 创建一个新线程。Executors 工具类的主要目的是简化线程池的创建和管理。
Java并发编程（六）线程池[Executor体系]
qq_34020761的博客
08-14 605
本文重点讲述线程池的相关内容,目的就是利用它可以有效的降低资源消耗、提高响应速度、提高线程的可管理性。
Executors线程池
weixin_59821542的博客
03-22 720
//工作中只用这种 // ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,//核心线程数 ExecutorService threadPoolExecutor = new ThreadPoolExecutor(2,//核心线程数 5,//最大线程数 1,//超时时间 TimeUni...
Executors-四种创建线程的手段
一个搬砖工人
11-26 1392
从构造方法可以看出，它创建了一个固定大小的线程池，每次提交一个任务就创建一个线程，直到线程数达到线程池的最大值nThreads。在提交第4个任务时，因为线程池的大小已经达到了3并且前3个任务在运行中，所以第4个任务被放入了队列，等待有空闲的线程时再被运行。这里的单线程执行指的是线程池内部，从线程池外的角度看，主线程在提交任务到线程池时并没有阻塞，仍然是异步的。因为这种线程有新的任务提交，就会创建新的线程（线程池中没有空闲线程时），不需要等待，所以提交的5个任务的运行时间是一样的。
​Java线程池详解​（+线程池多线程发邮件博客）
热门推荐
Java后端技术栈
12-25 1万+
构造一个线程池为什么需要几个参数？如果避免线程池出现OOM？Runnable和Callable的区别是什么？本文将对这些问题一一解答，同时还将给出使用线程池的常见场景和代码片段。 基础知识 Executors创建线程池 Java中创建线程池很简单，只需要调用Executors中相应的便捷方法即可，比如Executors.newFixedThreadPool(int nThreads)，但是便捷不仅隐藏了复杂性，也为我们埋下了潜在的隐患（OOM，线程耗尽）。 Executors创建线程池便捷方法列表：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员老李头

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值