第一章：字节跳动Flink UDF场景的Go语言演进全景
在字节跳动实时计算平台中，Flink SQL作业长期依赖Java/Scala UDF处理复杂业务逻辑，但随着UDF规模增长至万级、单作业UDF调用量达每秒数百万次，JVM内存开销、GC延迟与开发迭代效率成为瓶颈。为突破这一限制，基础架构团队启动了Flink UDF的多语言支持演进，其中Go语言因其静态编译、低GC压力、高并发原生支持及与C生态无缝集成等特性，被选定为首批重点落地的语言。
Go UDF运行时架构设计
核心是轻量级Sidecar模型：Flink TaskManager启动时伴随一个独立Go进程（flink-go-udf-runner），通过Unix Domain Socket与JVM建立零拷贝通信通道。UDF函数以.so动态库形式加载，由Go runtime直接执行，规避序列化反序列化开销。通信协议采用Protocol Buffers v3定义，包含EvalRequest/EvalResponse结构体，支持批量调用与流式响应。
部署与集成流程
- 开发者使用
go-flink-udfSDK编写UDF（需实现Evaluate接口）； - 执行
make build-so生成跨平台.so文件（含CGO_ENABLED=1 GOOS=linux GOARCH=amd64）； - 将
.so与配置文件udf.yaml（声明函数名、输入输出类型、超时阈值）打包进Docker镜像； - 在Flink SQL中注册：
CREATE FUNCTION json_parse AS 'com.bytedance.flink.udf.GoUdf' USING JAR 'hdfs:///udf/go-json-parser.jar';注：
go-json-parser.jar为统一Java入口，仅负责路由请求至Sidecar进程，不承载业务逻辑。
性能对比关键指标（单节点TPS）
| 场景 | Java UDF | Go UDF | 提升幅度 |
|---|---|---|---|
| JSON解析（1KB） | 82,000 | 215,000 | +162% |
| 正则匹配（复杂模式） | 41,500 | 138,000 | +233% |
| 内存常驻峰值 | 2.4 GB | 0.7 GB | -71% |
该演进已支撑抖音推荐、TikTok风控等核心业务线，日均处理事件超2.3万亿条。后续将通过WASM沙箱进一步强化多租户隔离能力。
第二章：CGO桥接机制的深度解构与工程落地
2.1 CGO调用模型与Flink JVM Native Interface契约对齐
CGO 是 Go 与 C 交互的桥梁，而 Flink JVM Native Interface（JNI）定义了 Java 运行时与原生代码间的标准化契约。二者对齐的核心在于内存生命周期管理与异常传播语义的一致性。
数据同步机制
Flink JNI 要求 native 方法返回 jlong 表示资源句柄，而 CGO 中需通过 C.uintptr_t 显式转换并绑定 Go finalizer：
// 将 Java ByteBuffer 地址转为 Go []byte（零拷贝）
func jByteBufferToGoSlice(env *C.JNIEnv, jbuf C.jobject) []byte {
ptr := C.GetDirectBufferAddress(env, jbuf)
cap := C.GetDirectBufferCapacity(env, jbuf)
return (*[1 << 30]byte)(unsafe.Pointer(ptr))[:cap:cap]
}
GetDirectBufferAddress获取堆外内存起始地址；GetDirectBufferCapacity确保容量安全；强制切片转换规避 GC 移动风险。
关键对齐点对比
| 维度 | JNI 规范要求 | CGO 实现约束 |
|---|---|---|
| 错误码传递 | jint 返回 -1 表示失败 |
C.int(-1) + C.GoString() 日志回传 |
| 线程绑定 | 必须在 AttachCurrentThread 下调用 | C.AttachCurrentThread + defer Detach |
graph TD
A[Go worker goroutine] -->|cgoCall| B[C wrapper]
B -->|FindClass/GetMethodID| C[JVM thread attach]
C --> D[Flink native operator]
D -->|jlong handle| E[Go resource finalizer]2.2 跨运行时异常传播与栈回溯的零侵入式封装实践
在微服务与多语言混部场景中，异常需穿透 JVM/Go/Python 运行时边界，同时保留原始调用栈语义。
核心设计原则
- 异常元数据序列化（非对象直传）
- 栈帧符号化映射（跳过运行时私有帧）
- 上下文透传不依赖 SDK 注入
异常封装示例
public class CrossRuntimeError {
private final String errorId; // 全局唯一追踪 ID
private final String cause; // 原始异常类名（如 "java.lang.NullPointerException"）
private final List<StackFrame> frames; // 符号化栈帧（已过滤 native/internal 帧）
}该结构规避了跨运行时反序列化失败风险；errorId 支持分布式链路对齐，frames 仅保留业务相关栈帧，提升可观测性精度。
封装流程示意
graph TD
A[原始异常] --> B[提取符号化栈帧]
B --> C[序列化为 JSON-LD]
C --> D[HTTP/GRPC header 透传]
D --> E[目标运行时重建轻量异常]| 字段 | 类型 | 说明 |
|---|---|---|
errorId |
String | 全局唯一，由调用方生成并透传 |
cause |
String | 不含包路径的简洁异常名，保障跨语言兼容 |
frames |
List | 每帧含 className、methodName、lineNumber |
2.3 Go runtime与JVM线程模型协同调度的内存安全设计
当Go（通过GraalVM或JNI桥接）与JVM共存时，需在M:N（Go goroutine）与1:1（JVM线程）模型间建立内存可见性契约。
数据同步机制
Go runtime的runtime_pollWait与JVM的Unsafe.storeFence()需协同触发跨运行时内存屏障：
// 在CGO调用JVM方法前强制刷新写缓存
import "unsafe"
func syncToJVM(ptr unsafe.Pointer) {
runtime.GC() // 触发STW暂停，确保goroutine栈一致
atomic.StoreUint64((*uint64)(ptr), 1) // 带acquire-release语义
}atomic.StoreUint64生成x86-64 LOCK XCHG指令，确保对JVM堆的写入对Java线程可见；runtime.GC()触发STW保障goroutine栈根集合冻结。
协同调度关键约束
| 约束维度 | Go runtime侧 | JVM侧 |
|---|---|---|
| 栈内存归属 | goroutine私有栈 | Java线程栈不可共享 |
| 堆对象生命周期 | GC标记-清除 | G1/ ZGC并发回收 |
| 线程阻塞语义 | gopark移交M |
Object.wait()挂起 |
graph TD
A[Go goroutine] -->|park & handoff| B[OS thread M]
B -->|JNI AttachCurrentThread| C[JVM Thread]
C -->|synchronized block| D[Shared Heap Object]
D -->|WriteBarrier| E[JVM GC Card Table]
E -->|Barrier sync| F[Go GC Mark Phase]2.4 动态符号绑定与UDF热加载的CGO ABI兼容性保障
核心挑战：ABI稳定性边界
CGO调用C函数时，Go运行时需确保符号解析、调用约定（如cdecl/sysv）、内存布局（结构体对齐、字段偏移）与目标C库二进制完全一致。动态加载（dlopen）引入运行时符号解析，若UDF共享库升级后ABI变更（如函数签名修改、结构体新增字段），将触发未定义行为。
关键保障机制
- 符号版本化绑定：通过
.symver指令为导出符号绑定语义版本（如my_udf@V1.0） - ABI校验桩函数：UDF入口点强制返回
abi_version()整数，由Go侧校验是否匹配预期 - 零拷贝参数桥接：所有UDF入参统一经
C.struct_udf_args传递，避免Go struct直接暴露给C
兼容性校验代码示例
// UDF侧：导出带版本约束的符号
__attribute__((visibility("default")))
int32_t abi_version(void) {
return 0x010200; // V1.2.0 → 0xMMmmpp (Major.Minor.Patch)
}此函数被Go侧在
dlsym()后立即调用；返回值与预编译常量expected_abi = 0x010200比对，不匹配则拒绝加载。确保即使符号名未变，ABI语义变更也能被拦截。
运行时绑定流程（mermaid）
graph TD
A[Go调用 dlopen] --> B[读取UDF元数据]
B --> C{abi_version() == expected?}
C -->|是| D[执行 dlsym 获取符号]
C -->|否| E[panic: ABI mismatch]
D --> F[生成CGO wrapper]2.5 字节跳动内部CGO构建链路：Bazel+Gazelle自动化集成方案
字节跳动在大规模Go/C混合项目中，采用Bazel统一调度CGO构建，并通过定制化Gazelle插件实现自动依赖发现与BUILD文件生成。
构建规则扩展（cgo_library）
# WORKSPACE 中注册自定义规则
load("@io_bazel_rules_go//go:def.bzl", "go_register_toolchains", "go_rules_dependencies")
load("//tools/cgo:repositories.bzl", "cgo_deps")
cgo_deps() # 注册C工具链、pkg-config封装及头文件映射规则该宏注入@cgo_toolchain，支持跨平台CC/CXX环境隔离，并将#include <openssl/ssl.h>等路径自动映射至Bazel沙箱内声明的cc_library目标。
自动化依赖同步机制
- Gazelle插件扫描
.go文件中的import "C"及// #cgo指令 - 解析
#cgo LDFLAGS: -lfoo并关联@third_party//foo:lib - 生成
cgo_library目标，显式声明cdeps与copts
| 字段 | 作用 | 示例 |
|---|---|---|
cdeps |
C依赖库目标 | ["@openssl//:crypto"] |
copts |
C编译选项 | ["-Iexternal/openssl/include"] |
graph TD
A[Go源码含import “C”] --> B(Gazelle插件解析#cgo指令)
B --> C[生成cgo_library BUILD规则]
C --> D[Bazel执行C编译+Cgo绑定]
D --> E[输出静态链接的go_library]第三章：zero-copy内存共享的核心原理与性能验证
3.1 基于mmap+fd传递的跨进程共享内存池实现原理
传统共享内存（如 shm_open）需全局名称且权限管理复杂，而 mmap(MAP_SHARED) 配合 Unix 域套接字的文件描述符传递（SCM_RIGHTS），可实现无名、按需、细粒度的跨进程内存池分发。
核心协作流程
graph TD
A[生产者进程] -->|1. mmap 创建匿名共享区| B[内存池 buffer]
B -->|2. sendmsg + SCM_RIGHTS| C[Unix socket]
C -->|3. recvmsg 提取 fd| D[消费者进程]
D -->|4. mmap /dev/zero + offset| B内存映射关键代码
// 生产者：创建可传递的共享页
int fd = memfd_create("pool", MFD_CLOEXEC); // Linux 3.17+
ftruncate(fd, POOL_SIZE);
void *base = mmap(NULL, POOL_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, fd, 0); // 映射后 fd 仍有效
memfd_create生成内核托管的匿名文件描述符，无需文件系统路径；ftruncate设定大小；MAP_SHARED确保修改对其他映射可见。该fd可安全通过 Unix 域套接字传递给任意可信子进程。
fd 传递与二次映射
消费者收到 fd 后执行：
// 消费者：复用同一 fd 构建独立映射视图
void *view = mmap(NULL, POOL_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, received_fd, 0);
received_fd是recvmsg从控制消息中提取的副本，内核自动增加引用计数；两次mmap共享同一物理页帧，零拷贝同步。
| 机制 | 优势 | 约束 |
|---|---|---|
memfd_create |
无名、自动清理、支持 sealing | 仅 Linux ≥3.17 |
SCM_RIGHTS |
原子传递 fd，规避竞态 | 仅限 Unix 域套接字 |
MAP_SHARED |
跨进程缓存一致性（MESI 协议） | 需显式同步（如 seqlock） |
3.2 Flink MemorySegment与Go unsafe.Slice零拷贝映射实践
Flink 的 MemorySegment 是堆外内存的抽象，支持高效字节寻址与跨序列化复用；Go 中 unsafe.Slice(unsafe.Pointer(p), len) 可将原始指针零开销转为切片，二者在跨语言内存共享场景下形成天然协同。
零拷贝映射原理
- Flink 将
MemorySegment的address()转为long地址 - Go 通过
(*byte)(unsafe.Pointer(uintptr(addr)))构造起始指针 unsafe.Slice()直接映射指定长度，规避C.GoBytes复制开销
关键代码示例
// addr 来自 Flink MemorySegment.getAddress()（Java 端传入）
ptr := (*byte)(unsafe.Pointer(uintptr(addr)))
data := unsafe.Slice(ptr, int(length)) // length 由 Java 端同步传递
// ✅ 零拷贝：data 底层指向同一块堆外内存
// ⚠️ 注意：需确保 MemorySegment 生命周期 > Go 切片使用期逻辑分析：
uintptr(addr)将 Javalong地址转为 Go 原生指针整数；(*byte)强制类型转换为字节视图；unsafe.Slice在编译期生成无边界检查的切片头，不分配新内存。参数length必须严格匹配MemorySegment实际可用字节数，否则触发未定义行为。
| 对比维度 | Flink MemorySegment | Go unsafe.Slice |
|---|---|---|
| 内存位置 | 堆外（DirectBuffer） | 复用外部指针指向内存 |
| 生命周期管理 | 由 MemoryManager 回收 | 依赖外部同步释放 |
| 安全边界 | 运行时索引检查 | 无检查，需人工保障 |
graph TD
A[Flink JVM] -->|publish address & length| B[Go Runtime]
B --> C[unsafe.Slice ptr→data]
C --> D[直接解析 Protobuf/Avro]
D --> E[避免 memcpy + GC 压力]3.3 内存生命周期管理：从JVM DirectBuffer到Go runtime.GC的协同回收
Java NIO 的 DirectBuffer 在堆外分配内存，绕过 GC，但需显式调用 cleaner 回收；Go 则通过 runtime.SetFinalizer 关联 unsafe.Pointer 与 finalizer 函数，交由 runtime.GC 统一调度。
数据同步机制
JVM 与 Go 运行时间需避免双重释放或悬垂指针，常通过原子引用计数+跨语言屏障实现同步：
// Go 端注册 finalizer，确保仅在 runtime.GC 确认不可达后触发
runtime.SetFinalizer(&handle, func(h *bufferHandle) {
C.free(h.ptr) // 对应 JVM Cleaner#clean() 的 native free()
})逻辑分析：
handle持有C.malloc分配的地址；SetFinalizer将其绑定至 GC 生命周期，h.ptr参数为原始裸指针，必须保证在 finalizer 执行前未被提前释放。
协同回收关键约束
| 约束项 | JVM DirectBuffer | Go runtime.GC |
|---|---|---|
| 释放触发条件 | Cleaner#clean() 或 System.gc() | GC 标记-清除后 finalizer 队列执行 |
| 内存可见性 | 需 Unsafe.copyMemory 同步 |
依赖 runtimeWriteBarrier |
graph TD
A[JVM allocateDirect] --> B[Go 接收 ptr + size]
B --> C{引用计数 > 0?}
C -->|是| D[暂不回收]
C -->|否| E[runtime.GC 触发 finalizer]
E --> F[C.free]第四章：生产级Go UDF系统架构与稳定性治理
4.1 字节跳动Go UDF Runtime沙箱：资源隔离与OOM熔断机制
字节跳动为保障大规模实时计算中UDF（用户自定义函数）的安全执行，设计了基于 cgroups v2 + namespace 的轻量级 Go Runtime 沙箱。
资源硬限与动态配额
通过 libcontainer 封装的 cgroups 接口，对每个 UDF 实例施加 CPU Quota、内存 soft/hard limit 及 PIDs 数量限制：
// 初始化沙箱内存控制器（cgroup v2）
err := cgroup.NewManager("/udf/123", &cgroup.Spec{
Memory: &cgroup.Memory{
Limit: 512 * 1024 * 1024, // 512MB 硬上限
SoftLimit: 400 * 1024 * 1024, // OOM前触发熔断阈值
},
})该配置确保当进程 RSS 接近 400MB 时启动主动降级，达 512MB 则由内核 OOM Killer 终止，避免影响宿主调度器。
OOM熔断响应流程
graph TD
A[内存使用率 > 80%] --> B{是否启用熔断?}
B -->|是| C[触发GC强制回收+拒绝新UDF请求]
B -->|否| D[继续监控]
C --> E[若持续超软限3s → 标记沙箱为Degraded]关键参数对照表
| 参数 | 含义 | 默认值 | 生产建议 |
|---|---|---|---|
mem.soft_limit |
熔断触发阈值 | 80% hard_limit | 75%～85% |
oom_kill_disable |
是否禁用内核OOM Killer | false | false（必须启用） |
pids.max |
进程数上限 | 32 | 根据UDF并发度动态分配 |
4.2 分布式UDF元数据同步：etcd驱动的版本一致性与灰度发布
数据同步机制
UDF元数据以/udf/{name}/v{version}路径存于etcd，配合Revision和Lease ID实现强一致读写。每次注册/更新触发Watch事件广播。
灰度控制策略
- 按集群标签（
env=prod/staging）分组订阅 - 版本号支持语义化前缀（如
v2.1.0-alpha） - 灰度比例通过etcd中
/udf/{name}/canary_ratio动态配置
同步状态表
| 字段 | 类型 | 说明 |
|---|---|---|
version |
string | UDF语义化版本 |
checksum |
string | SHA256摘要，校验二进制一致性 |
active_since |
int64 | etcd revision，用于同步水位对齐 |
# etcd watch handler 示例
def on_udf_update(event):
key = event.key.decode()
if key.startswith(b'/udf/') and event.is_put:
meta = json.loads(event.value.decode())
# 仅当 checksum 匹配且 revision > local_watermark 时加载
if verify_checksum(meta['binary_url'], meta['checksum']):
load_udf_to_executor(meta)该逻辑确保Executor仅加载经校验且未跳过的版本；verify_checksum防止网络传输损坏，local_watermark避免重复或乱序加载。
graph TD
A[UDF注册请求] --> B[etcd事务写入/v{ver} + lease]
B --> C[Watch监听器捕获revision]
C --> D{版本是否在灰度范围内？}
D -->|是| E[热加载至目标Executor组]
D -->|否| F[跳过，保持旧版本]4.3 全链路可观测性：Go pprof+OpenTelemetry+Flink Metrics深度整合
构建统一观测平面需打通应用层、运行时与流处理三域指标。Go 服务通过 pprof 暴露实时性能剖面，OpenTelemetry SDK 统一采集并注入 trace context，Flink 作业则通过 MetricGroup 注册自定义指标并导出至同一后端（如 Prometheus）。
数据同步机制
OpenTelemetry Collector 配置如下：
receivers:
otlp:
protocols: { grpc: {} }
prometheus:
config:
scrape_configs:
- job_name: 'flink'
static_configs: [{ targets: ['flink-jobmanager:9249'] }]
exporters:
prometheusremotewrite:
endpoint: "http://prometheus:9090/api/v1/write"该配置实现 OTLP（Go 服务）与 Prometheus（Flink）双源汇聚，避免数据孤岛。
关键集成点
- Go 应用启用
runtime/pprof+otelcol-contribexporter - Flink 启用
metrics.reporter.otlp.class: io.opentelemetry.exporter.otlp.metrics.OtlpMetricsExporter - 所有 span 与 metric 共享
service.name和deployment.environment标签
| 组件 | 采集维度 | 协议 | 示例指标 |
|---|---|---|---|
| Go pprof | CPU/Mem/Block | HTTP | go_goroutines, runtime_memstats_alloc_bytes |
| OpenTelemetry | Trace/Log/Metric | OTLP/gRPC | http.server.request.duration |
| Flink | Checkpoint/Latency | Prometheus | taskmanager_job_latency_source_id |
4.4 故障注入与混沌工程：针对CGO阻塞与共享内存脏读的专项压测方案
核心故障建模
混沌实验聚焦两类关键缺陷：
- CGO调用未加超时导致 Goroutine 永久阻塞
- 多进程通过
mmap共享内存时缺乏内存屏障，引发脏读
注入示例（Go + C 混合场景）
// cgo_fault_injector.go
/*
#cgo LDFLAGS: -lpthread
#include <unistd.h>
#include <sys/mman.h>
void block_forever() { while(1) pause(); } // 模拟无响应C函数
*/
import "C"
func TriggerCGOBlock() { C.block_forever() } // 无goroutine封装，直接阻塞主线程逻辑分析：
block_forever在C侧无限循环且不响应信号；Go侧未启用runtime.LockOSThread()或go func(){...}()封装，导致P被独占，调度器无法抢占。cgo LDFLAGS确保链接 pthread 支持多线程安全上下文。
共享内存脏读验证表
| 进程A写入值 | 进程B读取值 | 是否同步？ | 原因 |
|---|---|---|---|
| 0x1234 | 0x0000 | 否 | 缺失 atomic.StoreUint64 + runtime.GC() 内存屏障 |
| 0x1234 | 0x1234 | 是 | 添加 syscall.Msync 强制刷回并配合 atomic.LoadUint64 |
混沌执行流程
graph TD
A[启动主服务+共享内存映射] --> B[注入CGO阻塞：触发 goroutine 泄漏]
B --> C[并发写入共享内存+移除 msync]
C --> D[多进程轮询读取并比对校验和]
D --> E{发现脏读 or P卡死？}
E -->|是| F[记录故障路径+堆栈快照]第五章：Go语言在实时计算基础设施中的未来图谱
生态协同演进路径
Go语言正深度融入实时计算主流生态。Flink 1.19起通过GraalVM原生镜像支持Go编写的UDF插件；Kafka Streams社区已落地Go客户端kgo（segmentio/kafka-go）的Exactly-Once语义增强模块，实测吞吐提升37%。TiDB 7.5新增的CDC Sink组件完全用Go重写，与PD调度器直连，将变更数据捕获延迟稳定压至82ms P99。这种“核心引擎C++/Rust + 编排层Go + 扩展点WebAssembly”的分层架构，已成为云原生实时平台的事实标准。
典型生产案例：字节跳动广告归因系统
该系统日均处理420亿次点击事件，采用Go重构后关键指标如下：
| 模块 | 旧架构（Java+Spring） | Go重构后 | 变化率 |
|---|---|---|---|
| 内存常驻占用 | 24GB/节点 | 6.8GB/节点 | ↓71.7% |
| 端到端P99延迟 | 312ms | 49ms | ↓84.3% |
| 故障恢复时间 | 42s | 1.8s | ↓95.7% |
核心优化在于：使用golang.org/x/exp/slices替代反射式JSON解析，自研ring buffer替代channel传递原始字节流，以及基于runtime/debug.SetGCPercent(5)的精细化内存调控。
面向异构硬件的运行时突破
Go 1.23引入的GOOS=linux GOARCH=arm64 GOARM=8交叉编译链已支持AWS Graviton3实例的SIMD指令集调用。某车联网平台将实时轨迹聚类算法（DBSCAN变种）用Go+NEON内联汇编重写，在边缘网关设备上实现单核每秒处理23万GPS点位——较纯Go版本提速4.2倍。其关键代码片段如下：
// NEON加速距离计算（简化示意）
func distanceNEON(p1, p2 []float32) float32 {
// 使用arm64.Intrinsics.Load128和Float32x4Sub等指令
// 实现4点并行欧氏距离计算
return math.Sqrt(float64(vaddvq_f32(
vmulq_f32(vsubq_f32(p1Vec, p2Vec), vsubq_f32(p1Vec, p2Vec)))))
}边缘-云协同计算范式
随着KubeEdge 1.12与Go Runtime的深度集成，实时计算任务可动态切分：高频传感器数据清洗在树莓派4B（Go交叉编译二进制仅12MB）完成，复杂模型推理卸载至云端GPU集群。某智慧工厂部署的预测性维护系统，通过Go实现的轻量级MQTT Broker（moqik/moqik）直接对接PLC，将振动信号FFT特征提取延迟控制在17ms内，同时利用net/http/pprof实时监控边缘节点GC压力。
安全可信执行环境构建
Confidential Computing正推动Go运行时变革。Intel TDX支持的go-tcb项目已在Linux Foundation孵化，其TEE内运行的实时风控服务已通过PCI-DSS认证。该服务将信用卡交易流式分析逻辑封装为独立enclave，所有密钥材料由SGX EPC内存保护，Go编译器自动注入__tcb_init()安全启动钩子，确保从ELF加载到goroutine调度全程可信。
开发者工具链成熟度跃迁
VS Code Go插件1.32版新增实时计算专用诊断能力：当检测到time.Ticker在goroutine中高频创建时，自动标记潜在资源泄漏；对sync.Pool误用场景（如Put非零值对象）提供实时修复建议。GoLand 2024.1内置的go tool trace可视化增强模块，可将10GB trace文件压缩为交互式火焰图，精准定位Kafka消费者组rebalance期间的goroutine阻塞链路。
flowchart LR
A[原始事件流] --> B{Go实时管道}
B --> C[协议解析<br/>Protobuf/Avro]
B --> D[状态管理<br/>BadgerDB嵌入式KV]
B --> E[窗口计算<br/>TTL-based sliding window]
C --> F[特征工程]
D --> F
E --> F
F --> G[输出到<br/>Kafka/Pulsar/ClickHouse]