java高并发系列 - 第19天：JUC中的Executor框架详解1，再不了解你就out啦

于 2024-04-04 02:46:23 发布
阅读量900 收藏 25
点赞数 19
分类专栏： 2024年程序员学习 文章标签： java python 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83627805/article/details/137362835
版权

  1. 介绍ExecutorService

  2. 介绍线程池ThreadPoolExecutor及案例

  3. 介绍定时器ScheduledExecutorService及案例

  4. 介绍Excecutors类的使用

  5. 介绍Future接口

  6. 介绍Callable接口

  7. 介绍FutureTask的使用

  8. 获取异步任务的执行结果的几种方法

Executors框架介绍

Executors框架是Doug Lea的神作，通过这个框架，可以很容易的使用线程池高效地处理并行任务。

Excecutor框架主要包含3部分的内容：

  1. 任务相关的：包含被执行的任务要实现的接口：Runnable接口或Callable接口

  2. 任务的执行相关的：包含任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架中有两个关键的类实现了ExecutorService接口（ThreadPoolExecutor和ScheduleThreadPoolExecutor）

  3. 异步计算结果相关的：包含接口Future和实现Future接口的FutureTask类

Executors框架包括：

  • Executor

  • ExecutorService

  • ThreadPoolExecutor

  • Executors

  • Future

  • Callable

  • FutureTask

  • CompletableFuture

  • CompletionService

  • ExecutorCompletionService

下面我们来一个个介绍其用途和使用方法。

Executor接口

Executor接口中定义了方法execute(Runable able)接口，该方法接受一个Runable实例，他来执行一个任务，任务即实现一个Runable接口的类。

ExecutorService接口

ExecutorService继承于Executor接口，他提供了更为丰富的线程实现方法，比如ExecutorService提供关闭自己的方法，以及为跟踪一个或多个异步任务执行状况而生成Future的方法。

ExecutorService有三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown()方法时，便进入了关闭状态，此时意味着ExecutorService不再接受新的任务，但是他还是会执行已经提交的任务，当所有已经提交了的任务执行完后，便达到终止状态。如果不调用shutdown方法，ExecutorService方法会一直运行下去，系统一般不会主动关闭。

ThreadPoolExecutor类

线程池类，实现了ExecutorService接口中所有方法，该类也是我们经常要用到的，非常重要，关于此类有详细的介绍，可以移步：[玩转java中的线程池]

ScheduleThreadPoolExecutor定时器

ScheduleThreadPoolExecutor继承自ScheduleThreadPoolExecutor，他主要用来延迟执行任务，或者定时执行任务。功能和Timer类似，但是ScheduleThreadPoolExecutor更强大、更灵活一些。Timer后台是单个线程，而ScheduleThreadPoolExecutor可以在创建的时候指定多个线程。

常用方法介绍：

schedule:延迟执行任务1次

使用ScheduleThreadPoolExecutor的schedule方法，看一下这个方法的声明：

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

3个参数：

command：需要执行的任务

delay：需要延迟的时间

unit：参数2的时间单位，是个枚举，可以是天、小时、分钟、秒、毫秒、纳秒等

示例代码：

package com.itsoku.chat18;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

* 跟着阿里p7学并发，微信公众号：javacode2018

*/

public class Demo1 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println(System.currentTimeMillis());

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

scheduledExecutorService.schedule(() -> {

System.out.println(System.currentTimeMillis() + “开始执行”);

//模拟任务耗时

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “执行结束”);

}, 2, TimeUnit.SECONDS);

}

}

输出：

1564575180457

1564575185525开始执行

1564575188530执行结束

scheduleAtFixedRate:固定的频率执行任务

使用ScheduleThreadPoolExecutor的scheduleAtFixedRate方法，该方法设置了执行周期，下一次执行时间相当于是上一次的执行时间加上period，任务每次执行完毕之后才会计算下次的执行时间。

看一下这个方法的声明：

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,

long initialDelay,

long period,

TimeUnit unit);

4个参数：

command：表示要执行的任务

initialDelay：表示延迟多久执行第一次

period：连续执行之间的时间间隔

unit：参数2和参数3的时间单位，是个枚举，可以是天、小时、分钟、秒、毫秒、纳秒等

假设系统调用scheduleAtFixedRate的时间是T1，那么执行时间如下：

第1次：T1+initialDelay

第2次：T1+initialDelay+period

第3次：T1+initialDelay+2*period

第n次：T1+initialDelay+(n-1)*period

示例代码：

package com.itsoku.chat18;

import java.sql.Time;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 跟着阿里p7学并发，微信公众号：javacode2018

*/

public class Demo2 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println(System.currentTimeMillis());

//任务执行计数器

AtomicInteger count = new AtomicInteger(1);

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

scheduledExecutorService.scheduleAtFixedRate(() -> {

int currCount = count.getAndIncrement();

System.out.println(Thread.currentThread().getName());

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “开始执行”);

try {

TimeUnit.SECONDS.sleep(2);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “执行结束”);

}, 1, 1, TimeUnit.SECONDS);

}

}

前面6次输出结果：

1564576404181

pool-1-thread-1

1564576405247第1次开始执行

1564576407251第1次执行结束

pool-1-thread-1

1564576407251第2次开始执行

1564576409252第2次执行结束

pool-1-thread-2

1564576409252第3次开始执行

1564576411255第3次执行结束

pool-1-thread-1

1564576411256第4次开始执行

1564576413260第4次执行结束

pool-1-thread-3

1564576413260第5次开始执行

1564576415265第5次执行结束

pool-1-thread-2

1564576415266第6次开始执行

1564576417269第6次执行结束

代码中设置的任务第一次执行时间是系统启动之后延迟一秒执行。后面每次时间间隔1秒，从输出中可以看出系统启动之后过了1秒任务第一次执行（1、3行输出），输出的结果中可以看到任务第一次执行结束时间和第二次的结束时间一样，为什么会这样？前面有介绍，任务当前执行完毕之后会计算下次执行时间，下次执行时间为上次执行的开始时间+period，第一次开始执行时间是1564576405247，加1秒为1564576406247，这个时间小于第一次结束的时间了，说明小于系统当前时间了，会立即执行。

scheduleWithFixedDelay:固定的间隔执行任务

使用ScheduleThreadPoolExecutor的scheduleWithFixedDelay方法，该方法设置了执行周期，与scheduleAtFixedRate方法不同的是，下一次执行时间是上一次任务执行完的系统时间加上period，因而具体执行时间不是固定的，但周期是固定的，是采用相对固定的延迟来执行任务。看一下这个方法的声明：

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,

long initialDelay,

long delay,

TimeUnit unit);

4个参数：

command：表示要执行的任务

initialDelay：表示延迟多久执行第一次

period：表示下次执行时间和上次执行结束时间之间的间隔时间

unit：参数2和参数3的时间单位，是个枚举，可以是天、小时、分钟、秒、毫秒、纳秒等

假设系统调用scheduleAtFixedRate的时间是T1，那么执行时间如下：

第1次：T1+initialDelay，执行结束时间：E1

第2次：E1+period，执行结束时间：E2

第3次：E2+period，执行结束时间：E3

第4次：E3+period，执行结束时间：E4

第n次：上次执行结束时间+period

示例代码：

package com.itsoku.chat18;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 跟着阿里p7学并发，微信公众号：javacode2018

*/

public class Demo3 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println(System.currentTimeMillis());

//任务执行计数器

AtomicInteger count = new AtomicInteger(1);

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

scheduledExecutorService.scheduleWithFixedDelay(() -> {

int currCount = count.getAndIncrement();

System.out.println(Thread.currentThread().getName());

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “开始执行”);

try {

TimeUnit.SECONDS.sleep(2);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “执行结束”);

}, 1, 3, TimeUnit.SECONDS);

}

}

前几次输出如下：

1564578510983

pool-1-thread-1

1564578512087第1次开始执行

1564578514091第1次执行结束

pool-1-thread-1

1564578517096第2次开始执行

1564578519100第2次执行结束

pool-1-thread-2

1564578522103第3次开始执行

1564578524105第3次执行结束

pool-1-thread-1

1564578527106第4次开始执行

1564578529106第4次执行结束

延迟1秒之后执行第1次，后面每次的执行时间和上次执行结束时间间隔3秒。

scheduleAtFixedRate和scheduleWithFixedDelay示例建议多看2遍。

定时任务有异常会怎么样？

示例代码：

package com.itsoku.chat18;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 跟着阿里p7学并发，微信公众号：javacode2018

*/

public class Demo4 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println(System.currentTimeMillis());

//任务执行计数器

AtomicInteger count = new AtomicInteger(1);

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(() -> {

int currCount = count.getAndIncrement();

System.out.println(Thread.currentThread().getName());

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “开始执行”);

System.out.println(10 / 0);

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “执行结束”);

}, 1, 1, TimeUnit.SECONDS);

TimeUnit.SECONDS.sleep(5);

System.out.println(scheduledFuture.isCancelled());

System.out.println(scheduledFuture.isDone());

}

}

系统输出如下内容就再也没有输出了：

1564578848143

pool-1-thread-1

1564578849226第1次开始执行

false

true

先说补充点知识：schedule、scheduleAtFixedRate、scheduleWithFixedDelay这几个方法有个返回值ScheduledFuture，通过ScheduledFuture可以对执行的任务做一些操作，如判断任务是否被取消、是否执行完成。

再回到上面代码，任务中有个10/0的操作，会触发异常，发生异常之后没有任何现象，被ScheduledExecutorService内部给吞掉了，然后这个任务再也不会执行了，scheduledFuture.isDone()输出true，表示这个任务已经结束了，再也不会被执行了。所以如果程序有异常，开发者自己注意处理一下，不然跑着跑着发现任务怎么不跑了，也没有异常输出。

取消定时任务的执行

可能任务执行一会，想取消执行，可以调用ScheduledFuture的cancel方法，参数表示是否给任务发送中断信号。

package com.itsoku.chat18;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 跟着阿里p7学并发，微信公众号：javacode2018

*/

public class Demo5 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

System.out.println(System.currentTimeMillis());

//任务执行计数器

AtomicInteger count = new AtomicInteger(1);

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);

ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(() -> {

int currCount = count.getAndIncrement();

System.out.println(Thread.currentThread().getName());

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “开始执行”);

try {

TimeUnit.SECONDS.sleep(2);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(System.currentTimeMillis() + “第” + currCount + “次” + “执行结束”);

}, 1, 1, TimeUnit.SECONDS);

TimeUnit.SECONDS.sleep(5);

scheduledFuture.cancel(false);

TimeUnit.SECONDS.sleep(1);

System.out.println(“任务是否被取消：”+scheduledFuture.isCancelled());

System.out.println(“任务是否已完成：”+scheduledFuture.isDone());

}

}

输出：

1564579843190

pool-1-thread-1

1564579844255第1次开始执行

1564579846260第1次执行结束

pool-1-thread-1

1564579847263第2次开始执行

任务是否被取消：true

任务是否已完成：true

1564579849267第2次执行结束

输出中可以看到任务被取消成功了。

Executors类

Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。常用的方法有：

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor()

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
img
img
img
img
img
img

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
img

Kafka实战笔记

关于这份笔记，为了不影响大家的阅读体验，我只能在文章中展示部分的章节内容和核心截图

image.png

  • Kafka入门
  • 为什么选择Kafka
  • Karka的安装、管理和配置

image.png

  • Kafka的集群
  • 第一个Kafka程序
  • image.png

afka的生产者

image.png

  • Kafka的消费者
  • 深入理解Kafka
  • 可靠的数据传递

image.png

image.png

  • Spring和Kalka的整合
  • Sprinboot和Kafka的整合
  • Kafka实战之削峰填谷
  • 数据管道和流式处理(了解即可)

image.png

  • Kafka实战之削峰填谷

image.png

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

8541)]

  • Kafka入门
  • 为什么选择Kafka
  • Karka的安装、管理和配置

[外链图片转存中…(img-Q1LDPFjy-1712169968541)]

  • Kafka的集群
  • 第一个Kafka程序
  • [外链图片转存中…(img-VroUJZrY-1712169968542)]

afka的生产者

[外链图片转存中…(img-IaPKzzMx-1712169968542)]

  • Kafka的消费者
  • 深入理解Kafka
  • 可靠的数据传递

[外链图片转存中…(img-aFPt8Ssm-1712169968542)]

[外链图片转存中…(img-XKZyz8lD-1712169968542)]

  • Spring和Kalka的整合
  • Sprinboot和Kafka的整合
  • Kafka实战之削峰填谷
  • 数据管道和流式处理(了解即可)

[外链图片转存中…(img-FvCgsinh-1712169968543)]

  • Kafka实战之削峰填谷

[外链图片转存中…(img-7E6n7J55-1712169968543)]

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

2401_83627805
关注
  • 19
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java高并发源码-java-concurrent:Java高并发，JUC，相关源码。1、马士兵高并发视频源码（听课时练习）
05-24
Java并发编程是Java开发中的重要领域，特别是在大型分布式系统或高性能应用中，对并发处理的需求尤为突出。"java-concurrent"这个项目显然聚焦于Java并发编程的实践与学习，特别是通过马士兵老师的高并发视频课程的...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
[JUC] 线程池浅析
最新发布
长夜烛火的博客
12-05 66
​ 线程池是一种利用池化技术思想来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的创建和任务的执行解耦开来。可以通过创建线程池来复用已创建的线程来降低频繁创建和销毁线程所带来的资源消耗。
Executors框架
菩提本无树 明镜亦非台 本来无一物 何处惹尘埃
01-17 602
通常java最简单的线程的例子是这样的： 在较小的程序中这样实践是没有问题的；但是在大规模的应用中将线程的管理和创建部分与应用部分分开则比较合理。可以提高管理效率和节省线程反复创建和销毁带来的开销。 那么封装了线程管理和创建这些功能的对象就是 java.util.concurrent.Executors ...
Executor框架
qq_41820066的博客
12-06 361
Executor框架
Java并发来一发（三）Java线程池
CoffeDaddy的专栏
11-30 281
目录 一、线程池概念 二、线程池状态 三、Excecutors四种创建线程池方法 四、Java中的ThreadPoolExecutor类 五、线程执行流程 六、一个简单的线程池实现 一、线程池概念 线程池是一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代...
Java并发工具-4-并发框架(Executor&ForkJoin)
qq_40589140的博客
11-08 336
Java 1.7 引入了一种新的并发框架—— Fork/Join Framework，主要用于实现“分而治之”的算法，特别是分治之后递归调用的函数。ForkJoin框架的本质是一个用于并行执行任务的框架， 能够把一个大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务的计算结果。在Java中，ForkJoin框架与ThreadPool共存，并不是要替换ThreadPool其实，在Java 8中引入的并行流计算，内部就是采用的ForkJoinPool来实现的。
java8集合源码分析-JUC:高并发与多线程
06-04
高并发与多线程 Stargazers over time 线程 线程的创建和启动 线程的sleep、yield、join 线程的状态 代码在 部分。 synchronized关键字(悲观锁) synchronized(Object) 不能用String常量、Integer、Long。 锁住的是...
java并发编程专题（十）----(JUC原子类)基本类型详解
08-18
Java并发编程专题（十）----(JUC原子类)基本类型详解 本资源主要介绍了Java JUC原子类基本类型的相关知识点，包括AtomicInteger、AtomicLong、AtomicBoolean等基本类型的使用方法和原理。通过对原子操作和 일반操作...
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
Java.util.concurrent（JUC）是Java平台中处理高并发的核心工具包，它为开发者提供了丰富的并发组件和机制，使得在多线程环境下的编程变得更加高效和安全。本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类...
【java并发】Executor框架详解
九离的博客
03-26 774
Java并发——Executor框架详解 一、Executor框架概念 我们知道线程池就是线程的集合，线程池集中管理线程，以实现线程的重用，降低资源消耗，提高响应速度等。线程用于执行异步任务，单个的线程既是工作单元也是执行机制，从JDK1.5开始，为了把工作单元与执行机制分离开，Executor框架诞生了，他是一个用于统一创建与运行的接口。Executor框架实现的就是线程池的功能。 二、Executor框架结构详解 2.1 Executor框架 （1）任务。也就是工作单元，包括被执行任务需要实现的接
Spring Boot 实现监控子线程的执行结果2种方法（Future.isDone()、事件监听器）
旭东怪的博客
09-18 2408
1 Maven依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <!--hutool工
Java 并发编程 11 - 异步执行框架 Executor
justlpf的专栏
05-16 598
下面是这些类和接口的简介。Executor是一个接口，它是 Executor 框架的基础，它将任务的提交与任务的执行分离开来。是线程池的核心实现类，用来执行被提交的任务。是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor 比 Timer 更灵活，功能更强大。Future接口和实现 Future 接口的FutureTask类，代表异步计算的结果。Runnable接口和Callable。
Executor框架---简介
喜三仔的世界
10-09 180
 在Java中，使用线程来异步执行任务。Java线程的创建与销毁需要一定的开销，如果我们为每一个任务创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时，为每一个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。  Java的线程既是工作单元，也是执行机制。从JDK 5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机...
Executor框架详解
贾欣晓的博客
07-03 914
java的线程既是工作单元，也是执行机制。从jdk5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机制由Executor框架提供。在HotSpot VM的线程模型中，java线程被一对一映射为本地操作系统线程。java线程启动时会创建一个本地操作系统线程；当该java线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。在上层，java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务
深入了解 Java 中的 ScheduledFuture 类
fudaihb的博客
11-22 2187
在 Java 中，ScheduledFuture 接口是用于表示按计划执行的任务的一种方式。它是 Future 接口的子接口，提供了对计划任务执行的控制和管理。通常与 ScheduledExecutorService 接口一起使用，用于实现定时或延迟执行任务的需求。
史上最全的java线程池解析
it_manman的博客
12-19 503
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool...
6、并发编程基础-深入理解Excecutors执行器和线程池
青学博客
07-07 607
1、认识Excecutors执行器 Executor框架是指java 1.5中引入的一系列并发核心包，在在java.util.concurrent包中。其中并发包，Executor，Executors，ExecutorService，CompletionService，Future，Callable等，他们的关系为 其中在并发包中有一个比较重要的类：Executors，他扮演线程工厂的角色...
关于Future.cancel(false)
热门推荐
StefanTimber的博客
06-27 2万+
前言在学习Future接口的过程中，注意到它具有一个cancel()方法，用于取消异步的任务，它传入一个boolean类型的参数，传入true会中断线程停止任务，而传入false则会让线程正常执行至完成，并返回false。 由此让我产生了疑问，false参数并不会停止任务，那么cancel(false)有什么用呢？
Java并发编程详解：JUC工具包与多线程实战
"这是一份关于JUC高并发编程的狂神笔记，旨在帮助读者从入门到精通。笔记配合狂神在B站的同步课程，提供了深入浅出的学习材料，涵盖了Java并发API的核心内容。" Java并发编程是现代软件开发中的重要技能，尤其在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值