C#.NET TPL Dataflow 深入解析：数据流管道、背压控制与实战取舍

简介

很多人第一次接触 TPL Dataflow，往往是在这种场景里：

有一批数据要按阶段处理
每个阶段都可能是异步的
有的阶段想并行，有的阶段又想限流
生产速度和消费速度不一致
还希望上游结束时，下游也能优雅收尾

这类问题，用最直接的写法当然也能做：

自己起几个 Task
手写几个 ConcurrentQueue
再配上 SemaphoreSlim
最后自己维护结束信号和异常传播

能做，但通常会越来越散。

TPL Dataflow 解决的，正是这种"多阶段异步流水线"的组织问题。

一句话先说透：

TPL Dataflow 不是一个普通并发集合，也不是消息队列，而是一套在进程内组织异步处理管道的工具。

这篇文章我不想写成"块类型大全"。

更务实一点，我会围绕三个问题来讲：

它到底适合什么问题形状；
为什么有些场景用起来很顺，有些场景反而没必要；
在 .NET 里，它和 Channel、Parallel.ForEachAsync、Rx 的边界到底在哪。

先说结论：什么情况下你会想起 `TPL Dataflow`

如果你的代码开始长成下面这样：

text 复制代码

读取文件
-> 解析内容
-> 调外部接口补充数据
-> 批量写库

或者：

text 复制代码

接收工作项
-> 校验
-> 转换
-> 按条件分流
-> 最终落库或发通知

那你其实已经处在 TPL Dataflow 的典型适用区间了。

它特别适合这种场景：

明显是"流水线"
每一段职责比较单一
每一段都可能有不同的并发度和缓冲策略
你不想手写一堆队列和同步代码

`TPL Dataflow` 到底是什么？

它位于：

csharp 复制代码

System.Threading.Tasks.Dataflow

通常通过 NuGet 引用：

bash 复制代码

dotnet add package System.Threading.Tasks.Dataflow

可以先把它理解成一组可组合的"处理块"。

每个块只关心自己的一小段职责：

收到什么
怎么处理
产出什么
处理不过来时怎么办

然后再用链接把这些块串起来，形成一条完整的数据流。

所以它的核心心智模型不是：

"我有一个线程池怎么调"

而是：

"我有一条数据处理管道，每一段怎么定义和连接"

最小可运行示例：先别急着记块类型

先看一个完整但不复杂的例子。

假设你要处理一批图片地址，流程是：

下载
提取元数据
批量写库

csharp 复制代码

using System.Threading.Tasks.Dataflow;

var downloadBlock = new TransformBlock<string, byte[]>(
    async url =>
    {
        using var client = new HttpClient();
        return await client.GetByteArrayAsync(url);
    },
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = 4,
        BoundedCapacity = 8
    });

var parseBlock = new TransformBlock<byte[], ImageMeta>(
    bytes =>
    {
        // 这里用伪代码表示解析逻辑
        return new ImageMeta
        {
            Size = bytes.Length,
            Type = "jpg"
        };
    },
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount,
        BoundedCapacity = 16
    });

var batchBlock = new BatchBlock<ImageMeta>(20);

var saveBlock = new ActionBlock<ImageMeta[]>(
    async batch =>
    {
        // 模拟批量入库
        await Task.Delay(50);
        Console.WriteLine($"saved {batch.Length} items");
    },
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = 1,
        BoundedCapacity = 2
    });

downloadBlock.LinkTo(parseBlock, new DataflowLinkOptions { PropagateCompletion = true });
parseBlock.LinkTo(batchBlock, new DataflowLinkOptions { PropagateCompletion = true });
batchBlock.LinkTo(saveBlock, new DataflowLinkOptions { PropagateCompletion = true });

var urls = Enumerable.Range(1, 100)
    .Select(i => $"https://example.com/{i}.jpg");

foreach (var url in urls)
{
    await downloadBlock.SendAsync(url);
}

downloadBlock.Complete();
await saveBlock.Completion;

public sealed class ImageMeta
{
    public int Size { get; set; }
    public string Type { get; set; } = string.Empty;
}

这段代码里其实已经把 TPL Dataflow 最重要的几个点都用到了：

TransformBlock 做转换
BatchBlock 做聚合
ActionBlock 做最终副作用
MaxDegreeOfParallelism 控制每段并发
BoundedCapacity 做背压
PropagateCompletion 传播完成信号

如果你能把这个例子真正跑顺，后面的概念基本就不会太虚。

为什么这种写法比"自己拿几个队列拼起来"更顺？

因为 TPL Dataflow 自带了一整套处理流水线时绕不开的细节：

缓冲
并发
完成传播
错误传播
背压
分流和聚合

这些东西，单独看都不难。

真正让代码变乱的，是它们叠在一起之后的组合复杂度。

所以 TPL Dataflow 的价值不在于"性能魔法"，而在于：

让一条流水线的结构比手写同步拼装更清晰

它最核心的块，其实就几种

不用一上来把所有块全背下来，先记住最常用的这些就够了。

`BufferBlock<T>`

这是最像"中转队列"的块。

如果你只是想先收数据，再慢慢消费，它很合适。

`TransformBlock<TInput, TOutput>`

这是最常见的块。

接收一个输入，产出一个输出。

你可以把它理解成"流水线里的一个处理节点"。

`ActionBlock<T>`

这是流水线末端最常见的块。

它只消费，不再产出。

例如：

写数据库
发 HTTP 请求
记录日志

`TransformManyBlock<TInput, TOutput>`

一个输入，产出多个输出。

比如一段文本，拆成多个词；一个压缩包，拆成多个文件记录。

`BatchBlock<T>`

把多条消息聚成一批。

这个在批量写库、批量发请求时非常顺手。

`BroadcastBlock<T>`

把同一条消息发给多个下游。

适合做简单分发，但它不是"全功能事件总线"，别用过头。

从源码和接口层次看，`ISourceBlock` / `ITargetBlock` / `IPropagatorBlock` 怎么理解？

如果只停在块类型名字上，其实不太容易真正理解 TPL Dataflow 的设计。

更稳一点的方式，是先看它的接口层次。

`ITargetBlock<TInput>`

它代表"能接收消息的一端"。

你可以把它理解成：

数据流的消费者
流水线里的入口点或处理中转点的输入侧

像这些块都带有 target 属性：

ActionBlock<T>
TransformBlock<TInput, TOutput>
BufferBlock<T>

`ISourceBlock<TOutput>`

它代表"能产出消息的一端"。

你可以把它理解成：

数据流的生产者
流水线里的出口点或处理中转点的输出侧

像这些块都带有 source 属性：

BufferBlock<T>
TransformBlock<TInput, TOutput>
BatchBlock<T>

`IPropagatorBlock<TInput, TOutput>`

这个接口其实最值得记。

它表示：

既能吃输入
又能吐输出

也就是说，它是流水线里最典型的"处理中间节点"。

最常见的就是：

TransformBlock<TInput, TOutput>
TransformManyBlock<TInput, TOutput>

如果只用一句话记：

Target 管入口，Source 管出口，Propagator 就是中间处理节点。

这样再去看各种 block，心智模型会清楚很多。

为什么这套接口层次有价值？

因为它让 TPL Dataflow 的组合方式很统一。

例如 LinkTo 这件事，本质上就是：

一个 ISourceBlock<T>
连到一个 ITargetBlock<T>

而不是每种块都有自己的一套连接协议。

这也是它看起来能"搭积木"的原因。

从源码设计角度看，它不是一堆彼此孤立的类型，而是一套围绕消息输入、输出和传播关系建立起来的抽象。

真正要花心思的，不是块类型，而是这三个配置

很多文章会把块类型写得很满，但落到项目里，真正决定体验的通常是这三个东西。

1. `MaxDegreeOfParallelism`

它决定这一段最多同时跑多少个任务。

最简单的经验判断：

CPU 密集型：别设太大，通常看 CPU 核数
I/O 密集型：可以比 CPU 核数更高，但也别无脑开很大

如果你不清楚，就先保守一点。

很多 TPL Dataflow 代码变慢，不是因为块选错了，而是并发度配得太激进。

2. `BoundedCapacity`

这是我最建议认真对待的参数。

它的作用不是"让队列更专业"，而是：

给流水线做背压

如果上游生产太快、下游处理太慢，没有边界时，内存会一路涨。

BoundedCapacity 的意义就在于：

下游吃不动时，上游别再无限塞

这个参数在真实项目里非常重要，不是可有可无的"高级选项"。

3. `PropagateCompletion`

这个参数不复杂，但特别容易忘。

你如果希望：

上游 Complete()
下游也知道整条链该收尾了

那通常就该在 LinkTo 时打开它。

如果忘了，最典型的现象就是：

上游已经结束了
下游还一直等着

然后你开始以为自己哪里死锁了。

`TPL Dataflow` 最容易让人觉得"顺手"的地方：背压

这是它和很多"自己拿队列拼一下"写法拉开差距的点。

假设你有这样一条链：

text 复制代码

读文件 -> 解析 -> 调第三方 API -> 写库

真正慢的往往不是前两段，而是：

调第三方 API
写库

如果你不控制缓冲，上游会疯狂生产数据，把内存灌满。

而 TPL Dataflow 的 SendAsync + BoundedCapacity 这套配合，非常适合处理这种场景。

更直白一点说：

下游忙不过来，上游就会自然慢下来

这件事在做 ETL、导入、抓取、同步任务时特别有用。

`Post` 和 `SendAsync` 到底差在哪？

这个点非常值得单独讲，因为它直接影响你对背压的理解。

`Post`

Post 是同步尝试投递。

它的语义更像：

"我现在就试着把这条消息塞进去"
"能塞进去就返回 true"
"塞不进去就返回 false"

所以当目标块：

已满
已完成
当前拒绝接收

Post 就可能失败。

`SendAsync`

SendAsync 是异步投递。

它的语义更像：

"如果现在塞不进去，我愿意等一会"

因此它特别适合和：

BoundedCapacity

一起使用。

更务实地说：

Post 更像 try
SendAsync 更像 awaitable backpressure

如果你在写真正的生产者，并且希望上游能尊重下游吞吐，SendAsync 往往更合适。

什么时候用 `Post`？

通常是这些情况：

你不想等待
失败了可以直接丢弃或转旁路
你自己愿意处理"塞不进去"的结果

什么时候用 `SendAsync`？

通常是这些情况：

你希望生产者和消费者速度自然协调
你不想因为缓冲满了就直接丢消息
你需要背压，而不是"尽力塞一下"

如果只记一句话：

Post 是立即尝试，SendAsync 是可等待的投递。

错误传播和完成传播，才是它真正省心的地方

很多时候，异步流水线难写，不是因为"处理逻辑本身复杂"，而是因为你要自己处理：

某一段异常后，后面怎么办
整条链什么时候算结束
有没有还没处理完的数据

TPL Dataflow 把这些事情收进了块的生命周期里。

最常见的写法就是：

csharp 复制代码

upstream.LinkTo(downstream, new DataflowLinkOptions
{
    PropagateCompletion = true
});

然后：

csharp 复制代码

upstream.Complete();
await downstream.Completion;

这套写法看起来简单，但它替你省掉了很多本来要手写的"结束协议"。

`Complete()` 和 `Completion` 到底怎么理解？

这个点很小，但第一次看 TPL Dataflow 时特别容易混。

先直接记结论：

Complete()：告诉某个 block，"后面不会再有新消息进来了"
Completion：表示某个 block "什么时候才算真的处理完了"的那个 Task

也就是说，它们不是一回事。

`Complete()`

例如：

csharp 复制代码

readBlock.Complete();

它表达的是：

起点 block 不再接收新的输入
但已经接收进来的消息还会继续处理
处理完之后，再把完成信号往下游传播

所以 Complete() 更像：

主动发出"停止投喂新数据"的信号

`Completion`

例如：

csharp 复制代码

await saveBlock.Completion;

它表达的是：

等到这个 block 自己真正结束
如果它前面还有上游，也要等上游传下来的消息都处理完
如果中间有异常，这里也会把异常带出来

所以 Completion 更像：

等整条链真正收尾的那个等待点

放回这段代码里怎么理解？

csharp 复制代码

await readBlock.SendAsync("products.csv");
readBlock.Complete();
await saveBlock.Completion;

它的真实含义就是：

先把输入送进流水线
告诉起点：后面没有更多输入了
再等末端把整条流水线都处理干净

所以你可以把它简单记成：

Complete() 是"封口"
Completion 是"等收尾"

这也是为什么很多示例里，总是会看到：

从头部 block 调 Complete()
在尾部 block await Completion

一个更贴近项目的实践案例

假设你在做一个"商品导入"后台任务：

text 复制代码

读 Excel
-> 校验行数据
-> 调商品分类服务补充信息
-> 聚合成批
-> 批量写入数据库
-> 记录失败行

这就是很典型的 TPL Dataflow 场景。

为什么？

因为它天然就是分段处理，而且每段特征都不一样：

读文件：顺序读取
校验：CPU 轻度计算
查分类：I/O 密集
入库：批量、限流、要背压
失败行：旁路处理

如果你硬用一个大循环 + 一堆 Task.WhenAll 拼，当然也能写，但结构会越来越扁、越来越乱。

而 TPL Dataflow 的好处就在于：

每段职责是显性的
并发和缓冲策略是显性的
哪段慢、哪段堆积，也更容易观察

一个更完整的 ETL 落地案例

如果你想看一个更接近真实项目的版本，可以把场景换成：

text 复制代码

读取 CSV
-> 解析成 DTO
-> 校验字段
-> 调外部主数据服务补全分类
-> 按 100 条一批聚合
-> 批量写数据库
-> 错误记录单独落表

这时候一条相对完整的链会像这样：

csharp 复制代码

using System.Threading.Tasks.Dataflow;

var readBlock = new TransformManyBlock<string, string>(
    path => File.ReadLines(path));

var parseBlock = new TransformBlock<string, ProductImportRow?>(
    line =>
    {
        var parts = line.Split(',');
        if (parts.Length < 3) return null;

        return new ProductImportRow
        {
            Code = parts[0],
            Name = parts[1],
            CategoryCode = parts[2]
        };
    },
    new ExecutionDataflowBlockOptions
    {
        BoundedCapacity = 500
    });

var enrichBlock = new TransformBlock<ProductImportRow, ProductImportRow>(
    async row =>
    {
        await Task.Delay(10); // 模拟查主数据服务
        row.CategoryName = $"Category-{row.CategoryCode}";
        return row;
    },
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = 8,
        BoundedCapacity = 200
    });

var batchBlock = new BatchBlock<ProductImportRow>(100);

var saveBlock = new ActionBlock<ProductImportRow[]>(
    async rows =>
    {
        await Task.Delay(20); // 模拟批量入库
        Console.WriteLine($"saved batch: {rows.Length}");
    },
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = 1,
        BoundedCapacity = 2
    });

var errorBlock = new ActionBlock<string>(
    async line =>
    {
        await Task.Delay(1); // 模拟写错误表
        Console.WriteLine($"bad line: {line}");
    });

readBlock.LinkTo(parseBlock, new DataflowLinkOptions { PropagateCompletion = true });

parseBlock.LinkTo(
    enrichBlock,
    new DataflowLinkOptions { PropagateCompletion = true },
    row => row is not null);

parseBlock.LinkTo(
    new ActionBlock<ProductImportRow?>(_ => { }),
    row => row is null);

enrichBlock.LinkTo(batchBlock, new DataflowLinkOptions { PropagateCompletion = true });
batchBlock.LinkTo(saveBlock, new DataflowLinkOptions { PropagateCompletion = true });

await readBlock.SendAsync("products.csv");
readBlock.Complete();
await saveBlock.Completion;

public sealed class ProductImportRow
{
    public string Code { get; set; } = string.Empty;
    public string Name { get; set; } = string.Empty;
    public string CategoryCode { get; set; } = string.Empty;
    public string CategoryName { get; set; } = string.Empty;
}

这段代码当然还不算生产级，但它已经很接近真实项目里会遇到的问题形状了：

有输入拆分
有转换
有异步补全
有批处理
有背压
有分流

真正上线时，你通常还会继续补：

错误旁路真正落表，而不是只 Console.WriteLine
指标采集
单条失败重试
统一取消令牌
完整异常处理

但整体结构基本就是这条思路。

分流场景怎么写，才像真实项目？

不是所有消息都应该继续往主链走。

例如导入商品时：

校验通过的继续往下
校验失败的单独记录

这种时候你通常会用 LinkTo 的谓词重载。

csharp 复制代码

var validateBlock = new TransformBlock<ProductRow, ProductRow>(row => row);

var successBlock = new ActionBlock<ProductRow>(row =>
{
    Console.WriteLine($"valid: {row.Code}");
});

var errorBlock = new ActionBlock<ProductRow>(row =>
{
    Console.WriteLine($"invalid: {row.Code}");
});

validateBlock.LinkTo(successBlock, new DataflowLinkOptions { PropagateCompletion = true }, row => row.IsValid);
validateBlock.LinkTo(errorBlock, new DataflowLinkOptions { PropagateCompletion = true }, row => !row.IsValid);

这类写法很接近真实项目中的"分支处理"。

它和 `Channel<T>` 怎么选？

这是最值得讲清楚的一组对比。

Channel<T> 更像什么？

一个高性能、轻量级的生产者-消费者通道

TPL Dataflow 更像什么？

一套已经带好处理节点、背压、链接、分流、批处理的流水线工具箱

所以更务实地说：

如果你只是想做一个简单队列，Channel<T> 往往更轻
如果你已经明显进入多阶段处理、分流、批量、完成传播场景，TPL Dataflow 更顺手

它们不是谁全面替代谁，而是问题形状不同。

它和 `Parallel.ForEachAsync` 又怎么分？

Parallel.ForEachAsync 很适合：

对一组元素做并行处理
逻辑比较平
没有明显的多阶段流水线结构

但如果你的处理开始变成：

text 复制代码

A 阶段 -> B 阶段 -> C 阶段

而且每一段：

并发度不同
缓冲策略不同
结束条件不同

那 Parallel.ForEachAsync 就没那么顺了。

这时 TPL Dataflow 的结构优势会更明显。

它和 Rx 又不是一回事

很多人会把 TPL Dataflow 和 Rx 放一起看，这没错，但它们处理的重点不同。

Rx 更偏：

观察者模型
事件流组合
操作符表达能力

TPL Dataflow 更偏：

处理管道
消息块
并发执行和背压

如果你要做的是：

UI 事件流
时间窗口
debounce、throttle、merge 这类操作

Rx 往往更贴题。

如果你要做的是：

后台数据处理管道
ETL
多阶段并发任务流

TPL Dataflow 往往更自然。

几个真的很常见的坑

1. 忘记 `Complete()`

这是最常见的问题之一。

如果上游数据发完了却不调用 Complete()，下游就会一直等。

2. 忘记 `PropagateCompletion`

结果就是上游结束了，下游还挂着。

3. 并发度配太大

尤其是 I/O 场景，很多人一看能并发，就想直接开很高。

结果往往是：

第三方服务被打爆
数据库连接池吃紧
线程池压力增加

4. 不设 `BoundedCapacity`

这在导入、抓取、批处理项目里非常危险。

前面生产快，后面消费慢，内存会越来越高。

5. 在块里写太重的共享状态逻辑

TPL Dataflow 会帮你组织流水线，但不会自动替你消灭所有共享状态问题。

如果块内部还是一堆共享可变对象，那该踩的并发坑一样会踩。

一个非常务实的选择顺序

如果你在做 .NET 并发流水线设计，可以先按这个顺序判断：

只是简单并行遍历吗？
如果是，先看 Parallel.ForEachAsync
只是简单生产者-消费者吗？
如果是，先看 Channel<T>
如果已经是多阶段处理管道，并且需要背压、分流、批处理、完成传播，再考虑 TPL Dataflow

这个顺序很重要。

因为很多时候不是 TPL Dataflow 不好，而是问题根本没复杂到需要它。

面试里怎么答比较到位？

如果面试官问：

"TPL Dataflow 是什么，适合什么场景？"

一个比较自然的回答可以是：

TPL Dataflow 是 .NET 里用来搭建进程内异步数据处理管道的一套库。它把处理逻辑拆成多个可链接的数据流块，比如 TransformBlock、ActionBlock、BatchBlock，然后通过链接形成一条处理链。它特别适合多阶段流水线、背压控制、批处理、分流和完成传播这些场景。相比自己拿队列和 Task 拼，结构会清楚很多。

如果继续追问"它和 Channel<T> 的区别是什么"，可以答：

Channel<T> 更轻，更像一个高性能通道；TPL Dataflow 更像一个带好块类型、并发控制、背压和完成传播的流水线工具箱。简单生产消费用 Channel<T> 往往更合适，多阶段处理管道则更适合 TPL Dataflow。

如果再追问"最重要的配置项是什么"，优先答这三个：

MaxDegreeOfParallelism
BoundedCapacity
PropagateCompletion

总结

TPL Dataflow 最值得记住的，不是那些块的名字，而是它解决的问题形状：

当你的代码已经明显是一条"分阶段、异步、并发、需要背压和收尾协议"的处理管道时，TPL Dataflow 会让结构比手写队列和任务拼装清晰很多。

如果你只想记住几句话，可以记这几条：

它更适合进程内数据处理管道，不是 MQ 替代品；
真正关键的通常不是块类型，而是并发度、背压和完成传播；
BatchBlock、分流谓词和 ActionBlock 很贴近真实项目；
简单队列优先看 Channel<T>，简单并行遍历优先看 Parallel.ForEachAsync；
当问题已经明显是流水线时，再上 TPL Dataflow，会比较值。

C#.NET TPL Dataflow 深入解析：数据流管道、背压控制与实战取舍

简介

先说结论：什么情况下你会想起 TPL Dataflow

TPL Dataflow 到底是什么？

最小可运行示例：先别急着记块类型

为什么这种写法比"自己拿几个队列拼起来"更顺？

它最核心的块，其实就几种

BufferBlock<T>

TransformBlock<TInput, TOutput>

ActionBlock<T>

TransformManyBlock<TInput, TOutput>

BatchBlock<T>

BroadcastBlock<T>

从源码和接口层次看，ISourceBlock / ITargetBlock / IPropagatorBlock 怎么理解？

ITargetBlock<TInput>

ISourceBlock<TOutput>

IPropagatorBlock<TInput, TOutput>

为什么这套接口层次有价值？

真正要花心思的，不是块类型，而是这三个配置

1. MaxDegreeOfParallelism

2. BoundedCapacity

3. PropagateCompletion

TPL Dataflow 最容易让人觉得"顺手"的地方：背压

Post 和 SendAsync 到底差在哪？

Post

SendAsync

什么时候用 Post？

什么时候用 SendAsync？

错误传播和完成传播，才是它真正省心的地方

Complete() 和 Completion 到底怎么理解？

Complete()

Completion

放回这段代码里怎么理解？

一个更贴近项目的实践案例

一个更完整的 ETL 落地案例

分流场景怎么写，才像真实项目？

它和 Channel<T> 怎么选？

它和 Parallel.ForEachAsync 又怎么分？

它和 Rx 又不是一回事

几个真的很常见的坑

1. 忘记 Complete()

2. 忘记 PropagateCompletion

3. 并发度配太大

4. 不设 BoundedCapacity

5. 在块里写太重的共享状态逻辑

一个非常务实的选择顺序

面试里怎么答比较到位？

总结

先说结论：什么情况下你会想起 `TPL Dataflow`

`TPL Dataflow` 到底是什么？

`BufferBlock<T>`

`TransformBlock<TInput, TOutput>`

`ActionBlock<T>`

`TransformManyBlock<TInput, TOutput>`

`BatchBlock<T>`

`BroadcastBlock<T>`

从源码和接口层次看，`ISourceBlock` / `ITargetBlock` / `IPropagatorBlock` 怎么理解？

`ITargetBlock<TInput>`

`ISourceBlock<TOutput>`

`IPropagatorBlock<TInput, TOutput>`

1. `MaxDegreeOfParallelism`

2. `BoundedCapacity`

3. `PropagateCompletion`

`TPL Dataflow` 最容易让人觉得"顺手"的地方：背压

`Post` 和 `SendAsync` 到底差在哪？

`Post`

`SendAsync`

什么时候用 `Post`？

什么时候用 `SendAsync`？

`Complete()` 和 `Completion` 到底怎么理解？

`Complete()`

`Completion`

它和 `Channel<T>` 怎么选？

它和 `Parallel.ForEachAsync` 又怎么分？

1. 忘记 `Complete()`

2. 忘记 `PropagateCompletion`

4. 不设 `BoundedCapacity`