C C++最全Java多线程（六）：线程池详解_executors，2024年最新你头秃都没想到还能这样吧

最新推荐文章于 2024-05-21 09:57:05 发布
最新推荐文章于 2024-05-21 09:57:05 发布
阅读量573 收藏 29
点赞数 26
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978659/article/details/138871180
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

运行结果：

f5f73caaa109477fbb5186130114c8ac.png

3.2 带缓存的线程池（Executors.newCachedThreadPool）

线程池会根据任务数创建线程，并且在一定时间内可以重复使用这些线程。

示例代码：

public class ThreadPoolDemo4 {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            service.submit(() -> System.out.println("i:" + finalI + " 线程名称:" + Thread.currentThread().getName()));
        }
    }
}

运行结果：

46ec94f8e0684a9fb0e4dc50f984b317.png

该方式适用于短时间有且有大量任务的场景，它的缺点是可能占用很多资源。

3.3 执行定时任务（Executors.newSingleThreadExecutor）

3.3.1 延迟执行（1次）

示例代码：

public class ThreadPoolDemo12 {
    public static void main(String[] args) {
        ScheduledExecutorService threadPool =
                Executors.newScheduledThreadPool(10);
        // 定时任务
        System.out.println("设置定时任务：" + new Date());
        // 延迟 n 秒后执⾏（只执⾏⼀次）
        threadPool.schedule(() -> System.out.println("schedule：" + new Date()), 2, TimeUnit.SECONDS);
    }
}

执行结果：

24d99ba8b075450c9b6fbf7c3de1208f.png

延迟 2s 后执行一次。

3.3.2 固定频率执行（ scheduleAtFixedRate）

示例代码：

public class ThreadPoolDemo13 {
    public static void main(String[] args) {
        ScheduledExecutorService threadPool =
                Executors.newScheduledThreadPool(10);
        // 定时任务
        System.out.println("设置定时任务：" + new Date());
        threadPool.scheduleAtFixedRate(() -> 
                System.out.println("scheduleAtFixedRate：" + new Date()), 3, 2, TimeUnit.SECONDS);
    }
}

运行结果：

d02c62b4d17244a99833d62de95ad1c3.png

延迟3s后执行，之后每2s执行一次。

参数解释：

  1. 参数1：执行任务；
  2. 参数2：延迟 n 秒后执行；
  3. 参数3：执行定时任务的频率；
  4. 参数4：配合参数3使用的时间单位。
3.3.3 scheduleAtFixedRate VS scheduleWithFixedDelay

scheduleAtFixedRate 是以上⼀次任务的开始时间，作为下次定时任务的参考时间的（参考时间+延迟任务=任务执行）。

示例代码：

public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        // 创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务执行时间：" + LocalDateTime.now());

        // 2s之后开始执行定时任务,定时任务每隔4s执行一次
        service.scheduleAtFixedRate(() -> {
            System.out.println("执行了任务：" + LocalDateTime.now());
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 2, 4, TimeUnit.SECONDS);
    }
}

运行结果：

d2eaa030a21045d8abb210f898cc803c.png

2s后开始执行定时任务，每隔5s执行一次。

设置的是每隔4秒执行一次定时任务，为什么实际上是5s执行一次呢？

6c048b2483f6b0a991f2625df7ba443a.jpg

注意，如果执行任务时间大于设置的定时任务执行时间，那么此方法会以执行任务的时间为准，简而言之，就是哪个时间长就以哪个时间作为定时任务执行的周期。

scheduleWithFixedDelay 是以上⼀次任务的结束时间，作为下次定时任务的参考时间的。

示例代码：

public class ThreadPoolDemo5 {
    public static void main(String[] args) {
        // 创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务执行时间：" + LocalDateTime.now());

        // 2s之后开始执行定时任务，每次执行间隔4秒
        service.scheduleWithFixedDelay(() -> {
            System.out.println("执行了任务：" + LocalDateTime.now());
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 2, 4, TimeUnit.SECONDS);
    }
}

运行结果：

31ee960d3f3f401a9898399ad76aa684.png

2s后开始执行任务，每隔9秒执行一次定时任务。

为什么这个也不是每隔4s执行一次，而是9s呢？？？

a9682dd3d74f6e825d0520c181230ffe.jpg

因为  scheduleWithFixedDelay 是以上⼀次任务的结束时间，作为下次定时任务的参考时间的，上个任务执行5s后，再延时4s执行延时任务。

3.4 定时任务单线程（Executors.newSingleThreadScheduledExecutor）

示例代码：

public class ThreadPoolDemo6 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        System.out.println("添加任务时间：" + LocalDateTime.now());
        service.schedule(() -> System.out.println("执行任务：" + LocalDateTime.now()), 2, TimeUnit.SECONDS);
    }
}

运行结果：

acd4cb63045e48f9a81563e624f37dba.png

3.5 单线程线程池（Executors.newSingleThreadExecutor）

示例代码：

public class ThreadPoolDemo7 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(() -> System.out.println("任务：" + finalI + ", 线程名：" + Thread.currentThread().getName()));
        }
    }
}

运行结果：

23cf3518d934489eba24f34b44b655a5.png

单线程的线程池有什么意义呢？

  1. 自定义拒绝策略；
  2. 提供了任务队列和任务管理的功能。

3.6 根据当前CPU生成线程池（Executors.newWorkStealingPool）

示例代码：

public class ThreadPoolDemo8 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newWorkStealingPool();
        for (int i = 0; i < 100; i++) {
            service.submit(() -> System.out.println("线程名：" + Thread.currentThread().getName()));
        }
        while (!service.isTerminated()){
        }
    }
}

运行结果：

3282d33482c2420a841adc8ce2913961.png

3.7 手动方式（ThreadPoolExecutor）

3.7.1 创建忽略最新任务的线程池

示例代码：

public class ThreadPoolDemo11 {
    public static void main(String[] args) {
        ThreadFactory factory = r -> {
            Thread thread = new Thread(r);
            return thread;
        };

        // 手动方式创建线程池
        ThreadPoolExecutor executor =
                new ThreadPoolExecutor(2, 2, 10, TimeUnit.SECONDS,
                        new LinkedBlockingDeque<>(2), factory, new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(finalI * 100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行任务" + finalI);
            });
        }
        // 终止线程池
        executor.shutdown();
    }
}

运行结果：

5e02e5d8fdb9479e8540bef1dfbaf048.png

3.7.2 ThreadPoolExecutor 参数说明
  1. corePoolSize：核心线程数，可以大致理解为长期驻留的线程数目（除非设置了allowCoreThreadTimeOut）。对于不同的线程池，这个值可能会有很大区别，比如newFixedThreadPool 会将其设置为 nThreads，而对于 newCachedThreadPool 则是为 0。
  2. maximumPoolSize：顾名思义，就是线程不够时能够创建的最⼤线程数。同样进⾏对比，对于newFixedThreadPool，当然就是 nThreads，因为其要求是固定大小，而 newCachedThreadPool 则是 Integer.MAX_VALUE。
  3. keepAliveTime：空闲线程的保活时间，如果线程的空闲时间超过这个值，那么将会被关闭。注意此值生效条件必须满足：空闲时间超过这个值，并且线程池中的线程数少于等于核⼼线程数corePoolSize。当然核心线程默认是不会关闭的，除非设置了allowCoreThreadTimeOut(true)那么核心线程也可以被回收。
  4. TimeUnit：时间单位。
  5. BlockingQueue：任务队列，用于存储线程池的待执行任务的。
  6. threadFactory：⽤于生成线程，⼀般我们可以⽤默认的就可以了。
  7. handler：当线程池已经满了，但是又有新的任务提交的时候，该采取什么策略由这个来指定。有几种方式可供选择，像抛出异常、直接拒绝然后返回等，也可以自己实现相应的接口实现自己的逻辑。
3.7.3 线程池执行流程

113ca706d90145e7a0c447a03452a610.png

3.7.4 拒绝策略（5种(4(JDK提供的) + 1(自定义拒绝策略)))

JDK提供的四种拒绝策略：

5376df4b44604ccea59dc230a36a04a2.png

  1. DiscardPolicy : 忽略旧任务（队列第一个任务）
  2. AbortPolicy : 提示异常，拒绝执行（默认的拒绝策略）
  3. CallerRunsPolicy : 使用调用线程池的线程来执行任务
  4. DiscardOldestPolicy :  忽略最新任务

自定义拒绝策略：

示例代码：

public class ThreadPoolDemo10 {
    public static void main(String[] args) {
        ThreadFactory factory = r -> {
            Thread thread = new Thread(r);
            return thread;
        };

        // 手动方式创建线程池
        ThreadPoolExecutor executor =
                new ThreadPoolExecutor(2, 2, 10, TimeUnit.SECONDS,
                        new LinkedBlockingDeque<>(2), factory,
                        new RejectedExecutionHandler() {
                            @Override
                            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                                // 自定义拒绝策略
                                System.out.println("自定义拒绝策略");
                            }
                        });
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(finalI * 100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行任务" + finalI);
            });
        }
        // 终止线程池
        executor.shutdown();
    }
}

运行结果:

595f02605134493bb8277ddb1d3642a2.png

4. 线程池状态

93068991d79144209ed23ac26517d1de.png

查看 ThreadPoolExecutor 源码可知线程的状态如下：

5f98cbbaf56148ad99837e1137b21abe.png

  • RUNNING：这是最正常的状态：接受新的任务，处理等待队列中的任务；
  • SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务；
  • STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程；
  • TIDYING：所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()；
  • TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个。

各个状态的转换过程有以下几种：

  • RUNNING -> SHUTDOWN：当调用了 shutdown() 后，会发生这个状态转换，这也是最重要的；
  • (RUNNING or SHUTDOWN) -> STOP：当调⽤ shutdownNow() 后，会发⽣这个状态转换；
  • SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING；
  • STOP -> TIDYING：当任务队列清空后，发⽣这个转换；
  • TIDYING -> TERMINATED：这个前面说了，当 terminated() 方法结束后。

shutdown VS shutdownNow ：

  • shutdown 执行时线程池终止接收新任务，并且会将任务队列中的任务处理完；
  • shutdownNow 执行时线程池终止接收新任务，并且会给终止执行任务队列中的任务。

shutdown ：

public class ThreadPoolDemo10 {
    public static void main(String[] args) {
        ThreadFactory factory = r -> {
            Thread thread = new Thread(r);
            return thread;


![img](https://img-blog.csdnimg.cn/img_convert/093bf4e459586d303c0485e75bad0af6.png)
![img](https://img-blog.csdnimg.cn/img_convert/18cea2bdc80c45b0a8b5f6ba8f72a7f1.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

hutdown ：**

public class ThreadPoolDemo10 {
public static void main(String[] args) {
ThreadFactory factory = r -> {
Thread thread = new Thread®;
return thread;

[外链图片转存中…(img-Ro3CZWqa-1715693536359)]
[外链图片转存中…(img-KVSVtobd-1715693536359)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

2401_84978659
关注
  • 26
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【转】浅谈C++ Executor
专注探索c++，Linux等后台开发相关机制，欢迎关注，欢迎交流
06-01 1049
浅谈The C++ Executors - 知乎
理解C++ Executor的设计理念
Erick Lv的笔记
06-25 4883
文章目录简介代码示例参考 简介 很多时候，我们的可调用对象需要某些非参数依赖的执行环境。可以这么理解，我们的任务是就绪的，不需要依赖外界传入参数了，只需要以某种方式控制方法的when 、where和how即可。 三个分别是指： where：可调用对象的执行位置，比如可以在内部或者外部的处理器(线程)上执行，并从内部或者外部的处理器(线程)上获取结果 when：可调用对象的执行时间，比如立刻执行或者被调度执行 how：可调用对象的执行方式，比如在CPU或者GPU上执行，可以矢量化计算等 举个例子： int
Java最新Java多线程（六）：线程池详解，mybatis的缓存面试题
2401_84692513的博客
05-11 675
DiscardPolicy : 忽略旧任务（队列第一个任务）AbortPolicy : 提示异常，拒绝执行（默认的拒绝策略）CallerRunsPolicy : 使用调用线程池的线程来执行任务DiscardOldestPolicy : 忽略最新任务自定义拒绝策略示例代码// 手动方式创建线程池@Override// 自定义拒绝策略System.out.println("自定义拒绝策略");});i < 5;
线程池详解
qq_41956309的博客
04-21 814
定义 线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制。它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。常见的运用池化思想的有：内存池、数据库连接池。使用线程池的优点如下： 优点 1.减少频繁创建和销毁线程的性能开销 2.重复利用线程 避免对每个任务都创建线程 可以提高响应速度 3.合理设置线程池的大小 可以避免因为线程池过大影响性能 线程池种类 1.Executors.newFixedT
Executor线程池源码详解
eg1107的博客
12-06 355
isRunning(c)是判断当前线程的生命状态，因为上面的if创建了核心线程，如果上面的if判断不满足，到这里的if线程已经被关闭了，isRunning(c)获取线程生命状态正常,workQueue.offer()意思是把任务放到队列中
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
多线程与线程池技术详解
06-12
4. **优势**：线程池能有效控制运行的线程数量，避免过多线程导致的资源消耗，同时还能控制任务的顺序和并发级别。 5. **线程池的关闭**：调用ExecutorService的shutdown()或shutdownNow()方法来优雅地关闭线程池，...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java简单实现多线程及线程池实例详解
08-27
"java简单实现多线程及线程池实例详解" 在java中，多线程是指在一个程序中可以同时运行多个线程，以提高程序的执行效率和性能。java提供了两种方式来实现多线程，即继承Thread类和实现Runnable接口。 继承Thread类...
tcp_thread_java.zip_Java 线程池_java TCP线程
09-14
Java线程池是一种高效管理线程资源的工具，它能够帮助开发者有效地控制并发执行的线程数量，提高系统性能，并确保程序的稳定性和可维护性。在Java中，线程池的实现主要依赖于`java.util.concurrent`包中的`...
executor:C ++多线程库
05-06
C ++ 11多线程库。 该库具有以下功能。 执行定期任务。 指定次数执行任务。 动态线程管理。 这个库，它将为您带来多线程的乐趣。 测试执行程序。 $ cd executor/cmake $ cmake . $ cmake --build . $ ctest
使用C++14执行器库实现高效异步编程
最新发布
gitblog_00073的博客
05-21 366
使用C++14执行器库实现高效异步编程 项目地址:https://gitcode.com/chriskohlhoff/executors 项目介绍 这是一个针对C++14的开源库，专注于执行器（Executor）的概念，它为异步编程提供了一种强大的模型。除了执行器，该库还包括定时器和通道功能，旨在帮助开发者构建高度可定制且易于管理的并发应用程序。本库已与g++ 4.8.2, g++ 4.9 和 c...
【多线程】自定义线程池中执行线程的统一名称
woluoyifan的博客
09-27 4886
新建线程池的时候，可以传入ThreadFactory作为参数  Executors.newCachedThreadPool(ThreadFactory threadFactory) 可以参考Executors自带的默认线程工厂类的实现 Executors.defaultThreadFactory(); static class NameableThreadFactory imple...
Java通过newCachedThreadPool和newFixedThreadPool创建的线程池详解
Deronn的博客
05-09 1707
public static ExecutorService newCachedThreadPool()创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被...
C++线程池ThreadPoolExecutor实现原理
Linuxhus的博客
03-20 945
1. 为什么要使用线程池 在实际使用中，线程是很占用系统资源的，如果对线程管理不善很容易导致系统问题。因此，在大多数并发框架中都会使用线程池来管理线程，使用线程池管理线程主要有如下好处： 降低资源消耗。通过复用已存在的线程和降低线程关闭的次数来尽可能降低系统性能损耗； 提升系统响应速度。通过复用线程，省去创建线程的过程，因此整体上提升了系统的响应速度； 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，因此，需要使用线程池来管理线程。 2. 线程池的工作
C++ 11 实现线程池---老外封装
小米的修行之路
02-24 1184
源码下载地址：https://github.com/log4cplus/ThreadPool // -*- C++ -*- // Copyright (c) 2012-2015 Jakob Progsch // // This software is provided 'as-is', without any express or implied // warranty. In no even...
c++11 thread 封装线程类
备忘录
01-21 4239
c++ thread也挺好用的，也可以像qt thread那样，start启动，run函数为线程的实际运行代码。thread和this_thread方法不多，常用的就几个。 1.std::this_thread::get_id 获取线程id 2.yield,和sleep。yield，交出cpu占有权，一般可以放到多线程的循环里，减少cpu空转 3.一般代码构建完thread，线程跑起
Executor入门 | Executor框架
跑龙套@程序
09-07 159
讲到并发就不得不讲一下Executor框架，其框架主要类关系图如下：   从图中可以看出来，接口Executor是框架知识点的引路者，那就从它讲起！     一：关于Executor的源码   /* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * Written by Doug Le...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值