登录
注册
开源
企业版
高校版
搜索
帮助中心
使用条款
关于我们
开源
企业版
高校版
私有云
Gitee AI
NEW
我知道了
查看详情
登录
注册
1月18日,北京,聊聊2025如何加入技术开发?
代码拉取完成,页面将自动刷新
捐赠
捐赠前请先登录
取消
前往登录
扫描微信二维码支付
取消
支付完成
支付提示
将跳转至支付宝完成支付
确定
取消
Watch
不关注
关注所有动态
仅关注版本发行动态
关注但不提醒动态
1
Star
1
Fork
0
独孤九剑
/
Java Learning
代码
Issues
69
Pull Requests
0
Wiki
统计
流水线
服务
Gitee Pages
JavaDoc
PHPDoc
质量分析
Jenkins for Gitee
腾讯云托管
腾讯云 Serverless
悬镜安全
阿里云 SAE
Codeblitz
我知道了,不再自动展开
更新失败,请稍后重试!
Issues
/
详情
移除标识
内容风险标识
本任务被
标识为内容中包含有代码安全 Bug 、隐私泄露等敏感信息,仓库外成员不可访问
线程池和多线程管理
待办的
#I8ZA9A
独孤九剑
拥有者
创建于
2024-01-26 21:13
**基本概念:** 一、线程池的体系结构: > Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy |--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象 |--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列 |--ScheduledExceutorService 接口:负责线程的调度 |--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService 二、工具类:Executors > ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池 ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。 ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程 ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务 ...... 1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。 2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一个执行完成的任务,从而阻塞主线程造成浪费。 3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。 - 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。 - `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。 - `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。 - `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。 - `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。 4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。 ``` thenApply // 有入参和返回参数 thenApplyAsync thenAccept // 只有入参没有返回参数 thenAcceptAsync acceptEither // 接收任意一个处理完的任务 thenRun // 没有入参没有返回参数 thenRunAsync thenCombine // 有序组合 thenCombineAsync thenCompose // 无序组合 thenComposeAsync whenComplete/handle/exceptionally // 任务执行完毕后的处理任务 allOf().join() // 阻塞等待所有任务 anyOf().join() // 阻塞等待任一任务 ```
**基本概念:** 一、线程池的体系结构: > Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy |--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象 |--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列 |--ScheduledExceutorService 接口:负责线程的调度 |--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService 二、工具类:Executors > ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池 ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。 ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程 ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务 ...... 1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。 2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一个执行完成的任务,从而阻塞主线程造成浪费。 3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。 - 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。 - `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。 - `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。 - `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。 - `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。 4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。 ``` thenApply // 有入参和返回参数 thenApplyAsync thenAccept // 只有入参没有返回参数 thenAcceptAsync acceptEither // 接收任意一个处理完的任务 thenRun // 没有入参没有返回参数 thenRunAsync thenCombine // 有序组合 thenCombineAsync thenCompose // 无序组合 thenComposeAsync whenComplete/handle/exceptionally // 任务执行完毕后的处理任务 allOf().join() // 阻塞等待所有任务 anyOf().join() // 阻塞等待任一任务 ```
评论 (
0
)
独孤九剑
创建了
任务
独孤九剑
修改了
标题
原值
多线程
新值
线程池和多线程管理
独孤九剑
修改了
描述
原值
**基本概念:**
新值
**基本概念:**
独孤九剑
修改了
描述
原值
**基本概念:**
新值
**基本概念:**
并发和并行区别在于是不是“同时”,并发是交替执行,并行是同时执行多任务。
独孤九剑
修改了
描述
原值
**基本概念:**
并发和并行区别在于是不是“同时”,并发是交替执行,并行是同时执行多任务。
新值
**基本概念:**
继承关系:
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口: 线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口: 负责线程的调度
|--ScheduledThreadPoolExecutor : 继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类 : Executors
>
ExecutorService pool = Executors.newFixedThreadPool() : 创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool() : 缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor() :创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool() : 创建固定大小的线程,可以延迟或定时的执行任务
独孤九剑
修改了
描述
原值
**基本概念:**
继承关系:
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:
线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:
负责线程的调度
|--ScheduledThreadPoolExecutor
: 继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类 : Executors
>
ExecutorService pool = Executors.newFixedThreadPool() : 创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool() : 缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor() :创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool() : 创建固定大小的线程,可以延迟或定时的执行任务
新值
**基本概念:**
继承关系:
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:
线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:
负责线程的调度
|--ScheduledThreadPoolExecutor
:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类 : Executors
>
ExecutorService pool = Executors.newFixedThreadPool() : 创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool() : 缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor() :创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool() : 创建固定大小的线程,可以延迟或定时的执行任务
独孤九剑
修改了
描述
原值
**基本概念:**
继承关系:
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类
: Executors
>
ExecutorService pool = Executors.newFixedThreadPool()
: 创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool()
: 缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor()
:创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool()
: 创建固定大小的线程,可以延迟或定时的执行任务
新值
**基本概念:**
继承关系:
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类
:Executors
>
ExecutorService pool = Executors.newFixedThreadPool()
:创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool()
:缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor()
:创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool()
:创建固定大小的线程,可以延迟或定时的执行任务
独孤九剑
修改了
描述
原值
**基本概念:**
继承关系:
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--Exe
c
utorS
e
rvic
e
接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--Sch
e
d
u
ledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.n
e
wFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:负责线程的调度
|--S
c
hedul
e
dThr
e
adPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Ex
e
c
u
tors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Ex
e
cutors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口
,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回Future 对象
|--ThreadPoolExecutor 线程池的实现类
,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
Executor 相比 Thread 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略
AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回
Fut
u
re 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承
ThreadPoolExecutor,实现了ScheduledExecutorSe
r
vice
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
Executor 相比 Thread 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略
`AbortPolicy`
|--ExecutorService 接口:线程池的主要接口。增加了返回
`F
u
ture` 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承
`ThreadPoolExecutor`,实现了ScheduledExecuto
r
Service
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略
`AbortPolicy`
|--ExecutorService 接口:线程池的主要接口。增加了返回
`Future` 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承
`ThreadP
o
olExecutor`,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略
AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回
Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承
ThreadPo
o
lExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
```
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
```
二、工具类:Executors
```
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
```
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
```
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
```
二、工具类:Executors
```
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
```
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
text
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
text
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
text
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
text
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
`FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
`FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
`FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。
当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
`CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
`FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
`CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
`FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
`CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
`Executor` 相比
`Thread` 将任务本身和任务的执行解耦。
`FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
`CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取
先
完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor`
相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优
先
获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
-
在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
-
`CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的
`
poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
-
`CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
-
`CompletionService` 是
`
BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
-
`CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue
`
的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService
`
是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
编排的任务可以不是同构的。
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
编排的任务可以不是同构的。
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsy
n
c
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRu
n
// 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply
// 有入参和返回参数
thenA
pplyAsync
thenAccept
// 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun
// 没有入参没有返回参数
then
RunAsync
thenCombine
// 有序组合
thenCom
bin
e
Async
thenCompose
// 无序组合
t
henComp
oseAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApply
Async
thenA
ccept // 只有入参没有返回参数
thenAccept
Async
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRun
Async
then
Combine // 有序组合
thenCombine
Async
thenCom
pos
e
// 无序组合
thenCompose
Async
w
henComp
lete/handle/exceptionally // 任务执行完毕后的处理任务
```
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
``` thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
a
ccept
Either // 接收任意一个处理完的任务
thenRun /
/
没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
>
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenA
ccept
Async
acceptEither
/
/ 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
>
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回
参
数
thenApplyAsync
thenAccept // 只有入参没
有
返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参
没有
返回参数
thenRunAsy
n
c
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入
参
和返回参数
thenApplyAsync
thenAccept // 只
有
入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun //
没有
入参没有返回参数
thenRu
n
Async
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
```
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
allOf()
anyOf()
```
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
allOf()
anyOf()
```
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
allOf()
.join() // 阻塞等待所有任务
anyOf()
.join() // 阻塞等待任一任务
```
独孤九剑
添加了
JavaBasics
标签
独孤九剑
修改了
描述
原值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一
执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
allOf().join() // 阻塞等待所有任务
anyOf().join() // 阻塞等待任一任务
```
新值
**基本概念:**
一、线程池的体系结构:
>
Executor 负责线程的使用和调度的 根接口,默认饱和策略 AbortPolicy
|--ExecutorService 接口:线程池的主要接口。增加了返回 Future 对象
|--ThreadPoolExecutor 线程池的实现类,可以指定饱和策略,阻塞队列
|--ScheduledExceutorService 接口:负责线程的调度
|--ScheduledThreadPoolExecutor:继承 ThreadPoolExecutor,实现了ScheduledExecutorService
二、工具类:Executors
>
ExecutorService pool = Executors.newFixedThreadPool():创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool():缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor():创建单个线程池。 线程池中只有一个线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务
......
1. `Executor` 相比 `Thread` 将任务本身和任务的执行解耦。
2. `FutureTask` 是一个实现了 `Future` 接口和 `Runnable` 接口的类,它可以用于包装一个异步计算任务,可以在执行计算时提供取消任务、获取计算结果等功能。当执行批量的 `FutureTask` 的时候,`get()` 不一定获取到第一
个执行完成的任务,从而阻塞主线程造成浪费。
3. `CompletionService` 解决了 `FutureTask` 的缺陷,`take()/poll()` 优先获取先完成的任务并移出该元素,`take()` 会阻塞,`poll()` 会返回 null。
- 在执行大量相互独立和同构的任务时,可以使用 `CompletionService`。
- `CompletionService` 可以为任务的执行设置时限,主要是通过 `BlockingQueue` 的 `poll(long time,TimeUnit unit)` 为任务执行结果的取得限制时间,如果没有完成就取消任务。
- `CompletionService` 是在线程执行完拿到结果之后放入到了 `BlockingQueue` 中的。
- `CompletionService` 是 `BlockQueue.take()` 队列都拿完了,或者没有放入——才阻塞。
- `CompletionService` 取出所消耗的时间是哪个最后完成任务的时间。
4. `CompletableFuture` 除了提供了更为好用和强大的 `Future` 特性之外,还提供了函数式编程、异步任务编排组合(可以将多个异步任务串联起来,组成一个完整的链式调用)等能力。
```
thenApply // 有入参和返回参数
thenApplyAsync
thenAccept // 只有入参没有返回参数
thenAcceptAsync
acceptEither // 接收任意一个处理完的任务
thenRun // 没有入参没有返回参数
thenRunAsync
thenCombine // 有序组合
thenCombineAsync
thenCompose // 无序组合
thenComposeAsync
whenComplete/handle/exceptionally // 任务执行完毕后的处理任务
allOf().join() // 阻塞等待所有任务
anyOf().join() // 阻塞等待任一任务
```
展开全部操作日志
折叠全部操作日志
登录
后才可以发表评论
状态
待办的
待办的
进行中
已完成
已关闭
负责人
未设置
标签
JavaBasics
未设置
标签管理
里程碑
未关联里程碑
未关联里程碑
Pull Requests
未关联
未关联
关联的 Pull Requests 被合并后可能会关闭此 issue
分支
未关联
未关联
master
开始日期   -   截止日期
-
置顶选项
不置顶
置顶等级:高
置顶等级:中
置顶等级:低
优先级
不指定
严重
主要
次要
不重要
参与者(1)
1
https://gitee.com/843294669/learning.git
git@gitee.com:843294669/learning.git
843294669
learning
Java Learning
点此查找更多帮助
搜索帮助
Git 命令在线学习
如何在 Gitee 导入 GitHub 仓库
Git 仓库基础操作
企业版和社区版功能对比
SSH 公钥设置
如何处理代码冲突
仓库体积过大,如何减小?
如何找回被删除的仓库数据
Gitee 产品配额说明
GitHub仓库快速导入Gitee及同步更新
什么是 Release(发行版)
将 PHP 项目自动发布到 packagist.org
评论
仓库举报
回到顶部
登录提示
该操作需登录 Gitee 帐号,请先登录后再操作。
立即登录
没有帐号,去注册