第一章：哪些公司可以用go语言
Go语言凭借其简洁语法、卓越的并发模型、快速编译和高效运行时，已成为构建高并发、高可靠性基础设施服务的首选语言之一。它不绑定于特定行业或规模，任何重视工程效率、系统稳定性与团队协作可持续性的公司，均可将其纳入技术栈。
适合采用Go的典型企业类型
- 云原生与基础设施服务商：如Cloudflare、DigitalOcean、Twitch（早期核心服务迁移至Go），依赖Go的goroutine和channel实现百万级连接管理；
- 微服务架构主导的中大型互联网公司：Uber、LinkedIn、PayPal等使用Go重构API网关与内部RPC服务，显著降低延迟并提升部署密度；
- DevOps与SRE工具链建设团队：Docker、Kubernetes、Prometheus、Terraform等核心项目均以Go编写，企业自研CI/CD平台、配置中心或可观测性代理时，Go提供开箱即用的二进制分发能力；
- 初创公司与快速迭代团队：无需复杂虚拟机或运行时环境，单条
go build -o app main.go即可产出无依赖可执行文件，极大简化发布流程。
实际落地建议
若公司已有Go语言基础，可优先在以下场景试点：
- 编写轻量HTTP服务（如内部配置API）；
- 替换Python/Shell脚本为高性能CLI工具；
- 构建gRPC后端服务，配合Protocol Buffers定义接口。
示例：快速启动一个健康检查服务
package main
import (
"fmt"
"net/http"
"time"
)
func healthHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `{"status":"ok","timestamp":%d}`, time.Now().Unix())
}
func main() {
http.HandleFunc("/health", healthHandler)
fmt.Println("Server starting on :8080")
http.ListenAndServe(":8080", nil) // 启动HTTP服务器，监听8080端口
}执行go run main.go即可运行；生产环境推荐go build -ldflags="-s -w"生成精简二进制。
| 公司类型 | 典型用例 | 关键收益 |
|---|---|---|
| SaaS平台 | 多租户API网关 | 并发处理能力提升3–5倍 |
| 游戏公司 | 实时消息推送服务 | 连接保活内存占用降低40% |
| 金融科技企业 | 风控规则引擎微服务 | 启动时间 |
第二章：头部游戏厂商的Go语言落地实践
2.1 米哈游：高并发实时匹配系统架构演进与Go协程调度优化
早期匹配服务采用单体 Redis + 轮询扫描，QPS 瓶颈约 1.2k；2021 年起重构为基于 Go 的事件驱动架构，核心突破在于协程调度精细化控制。
匹配请求处理模型
func handleMatchReq(ctx context.Context, req *MatchRequest) {
// 使用带超时的协程池，避免 goroutine 泄漏
select {
case pool <- struct{}{}:
go func() {
defer func() { <-pool }() // 归还资源
matchEngine.Run(req) // 实际匹配逻辑
}()
case <-time.After(50 * time.Millisecond):
metrics.IncTimeout()
return // 快速失败
}
}pool 是容量为 500 的 channel 控制并发上限；50ms 超时保障 SLA；defer 确保资源归还，防止 goroutine 积压。
关键指标对比（峰值时段）
| 指标 | V1（轮询） | V2（Go 事件驱动） |
|---|---|---|
| P99 延迟 | 840ms | 47ms |
| 协程峰值数 | ~12k | ~3.2k |
| CPU 利用率 | 92% | 63% |
调度优化策略
- 动态调整
GOMAXPROCS至物理核数 × 1.2（实测最优） - 匹配任务按玩家段位分优先级队列，避免低段位长尾阻塞
- 使用
runtime.LockOSThread()绑定关键匹配器至专用 OS 线程
2.2 莉莉丝：微服务化转型中Go语言在网关层与匹配引擎的双模部署
在莉莉丝交易平台重构中，Go 语言被统一应用于 API 网关（基于 Gin）与核心匹配引擎（基于 Goroutine 池+无锁队列），实现“控制面轻量、数据面高性能”的双模部署。
架构分层对比
| 组件 | 并发模型 | 关键依赖 | 吞吐目标 |
|---|---|---|---|
| 网关层 | HTTP 请求协程 | gin, jwt-go |
15K QPS |
| 匹配引擎 | 固定 Worker 池 | sync/atomic, ring |
80K 订单/秒 |
匹配引擎核心调度逻辑
// 启动固定大小的匹配 Worker 池，避免 Goroutine 泛滥
func NewMatcherPool(size int) *MatcherPool {
pool := &MatcherPool{
tasks: make(chan *Order, 1e4), // 有界缓冲，防 OOM
wg: sync.WaitGroup{},
}
for i := 0; i < size; i++ {
pool.wg.Add(1)
go pool.worker() // 每个 worker 独立处理订单流
}
return pool
}tasks 通道容量设为 1e4，平衡延迟与内存占用；worker() 内部采用 select+default 非阻塞消费，保障毫秒级响应。Goroutine 池复用显著降低 GC 压力，实测 P99 延迟稳定在 3.2ms 以内。
数据同步机制
graph TD A[网关层接收 REST] –>|JSON 解析 + 校验| B[统一 Order DTO] B –> C[序列化为 Protobuf] C –> D[通过 gRPC 流式推送至匹配集群] D –> E[本地 RingBuffer 入队] E –> F[Worker 池原子出队+红黑树价格匹配]
2.3 鹰角网络：基于Go+eBPF的低延迟匹配链路可观测性体系建设
鹰角网络聚焦订单匹配引擎毫秒级链路追踪，将eBPF探针嵌入Linux内核socket层与调度器关键路径，实现零侵入、纳秒级事件采样。
核心数据采集架构
// bpf/probes.bpf.c —— 匹配请求入队时捕获上下文
SEC("tracepoint/syscalls/sys_enter_accept4")
int trace_accept(struct trace_event_raw_sys_enter *ctx) {
u64 pid = bpf_get_current_pid_tgid();
struct match_event event = {};
event.timestamp = bpf_ktime_get_ns(); // 纳秒级时间戳，用于端到端延迟计算
event.pid = pid >> 32;
bpf_map_push_elem(&match_events, &event, BPF_EXIST); // 使用per-CPU栈避免锁竞争
return 0;
}该eBPF程序在系统调用入口处无损捕获连接建立事件，bpf_ktime_get_ns()提供高精度时序基准，BPF_EXIST确保写入原子性，规避多核竞争。
观测指标维度
| 指标类别 | 示例字段 | 采集方式 |
|---|---|---|
| 延迟分布 | p99_match_us |
eBPF直方图映射 |
| 匹配吞吐 | matches_per_sec |
Go用户态聚合计数 |
| 内核调度抖动 | sched_delay_ns |
tracepoint/sched/sched_wakeup |
数据同步机制
- Go守护进程通过
libbpf-go轮询ringbuf获取事件流 - 实时反序列化后注入OpenTelemetry Collector，打标
service.name=matching-engine - 异步批处理写入Prometheus + Jaeger后端
graph TD
A[eBPF Socket Trace] --> B[RingBuf]
B --> C[Go用户态消费]
C --> D[OTLP Export]
D --> E[Prometheus Metrics]
D --> F[Jaeger Traces]2.4 叠纸游戏：Go语言在跨平台实时对战SDK中的内存模型与GC调优实践
叠纸游戏在《恋与制作人》实时PvP SDK中，采用 Go 构建低延迟同步层，直面 GC 停顿与跨平台内存碎片双重挑战。
内存分配策略优化
为规避频繁小对象堆分配，SDK 使用 sync.Pool 复用战斗事件结构体：
var eventPool = sync.Pool{
New: func() interface{} {
return &BattleEvent{ // 预分配字段，避免运行时扩容
Players: make([]PlayerState, 0, 4),
Timestamp: 0,
}
},
}sync.Pool 显著降低 GC 压力；make(..., 0, 4) 预设容量避免 slice 扩容导致的逃逸与拷贝。
GC 参数动态调优
根据对战房间生命周期调整 GC 频率：
| 场景 | GOGC | GOMEMLIMIT | 效果 |
|---|---|---|---|
| 匹配中（轻负载） | 100 | 512MiB | 平衡响应与吞吐 |
| 激战中（高吞吐） | 50 | 1GiB | 抑制 STW，容忍更高内存 |
数据同步机制
采用写时复制（Copy-on-Write）保障读写并发安全：
func (s *SyncState) Update(newData []byte) {
s.mu.Lock()
defer s.mu.Unlock()
s.data = append([]byte(nil), newData...) // 强制深拷贝，防止外部篡改
}该模式确保多 goroutine 读取 s.data 时无需加锁，仅写入路径串行化。
2.5 心动网络：从Node.js迁移至Go的QPS跃升路径与连接复用深度改造
心动网络原Node.js服务在高并发短连接场景下QPS卡在12k，CPU软中断与Event Loop争抢严重。迁移至Go后，通过连接池+上下文感知复用双引擎驱动，QPS提升至41k（+242%）。
连接复用核心改造
var pool = &sync.Pool{
New: func() interface{} {
return &http.Client{
Transport: &http.Transport{
MaxIdleConns: 200,
MaxIdleConnsPerHost: 200, // 避免单Host耗尽全局池
IdleConnTimeout: 30 * time.Second,
},
}
},
}sync.Pool避免高频http.Client创建开销；MaxIdleConnsPerHost按业务域名粒度隔离，防止热点Host挤占冷门Host连接。
性能对比关键指标
| 指标 | Node.js | Go（改造后） | 提升 |
|---|---|---|---|
| 平均延迟 | 48ms | 19ms | ↓60% |
| 连接建立耗时 | 12ms | 2.1ms | ↓82% |
| 内存常驻峰值 | 1.8GB | 620MB | ↓66% |
graph TD
A[HTTP请求] --> B{连接池检查}
B -->|空闲连接存在| C[复用已有连接]
B -->|无空闲连接| D[新建连接并加入池]
C --> E[发起TLS握手复用]
D --> E
E --> F[完成请求]第三章：中大型游戏公司的Go技术适配策略
3.1 匹配服务场景下的Go语言性能边界实测与压测建模
匹配服务典型负载为高并发、低延迟的双端ID对撞（如撮合、好友推荐），我们基于net/http与gorilla/mux构建基准服务，并用vegeta进行阶梯式压测（1k→10k RPS）。
压测关键指标对比
| 并发数 | P99延迟(ms) | GC暂停(us) | 内存占用(MB) |
|---|---|---|---|
| 2,000 | 18.3 | 124 | 142 |
| 8,000 | 67.9 | 489 | 536 |
核心匹配逻辑优化片段
// 使用 sync.Pool 复用匹配上下文，避免高频分配
var ctxPool = sync.Pool{
New: func() interface{} {
return &MatchContext{Pairs: make([][2]uint64, 0, 64)}
},
}
func matchBatch(ids []uint64) []*MatchResult {
ctx := ctxPool.Get().(*MatchContext)
defer ctxPool.Put(ctx) // 归还而非释放
ctx.Pairs = ctx.Pairs[:0] // 重置切片长度，保留底层数组
// ... 匹配逻辑
}
sync.Pool显著降低GC压力：压测中GC频次下降63%，P99延迟曲线拐点从4k RPS后移至7.2k RPS。make(..., 0, 64)预分配容量避免扩容抖动。
性能瓶颈归因路径
graph TD
A[QPS > 6k] --> B[goroutine调度延迟上升]
B --> C[netpoll阻塞加剧]
C --> D[sysmon检测到长时间G阻塞]
D --> E[触发强制STW扩容M]3.2 基于Go的分布式ID生成与状态同步一致性保障方案
核心设计目标
- 全局唯一、高吞吐、低延迟、时间有序
- 节点故障时 ID 生成不中断，状态变更强一致
Snowflake+Raft融合架构
type IDGenerator struct {
workerID uint16
sequence uint16
lastStamp int64 // 上次时间戳（毫秒）
raftNode *raft.Node // 参与Raft共识的状态机
}
workerID由Raft集群统一分配并持久化；sequence在单次时间戳内自增，溢出时阻塞等待下一毫秒；raftNode保证workerID分配与节点下线事件的线性一致性。
数据同步机制
| 组件 | 同步方式 | 一致性级别 |
|---|---|---|
| Worker ID分配 | Raft Log Apply | Linearizable |
| 时钟偏移检测 | NTP+心跳校验 | Bounded staleness |
| ID生成日志 | 异步WAL落盘 | Eventual |
状态恢复流程
graph TD
A[节点启动] --> B{Raft Leader?}
B -->|Yes| C[广播WorkerID申请]
B -->|No| D[同步最新WorkerID映射表]
C --> E[写入Raft Log]
D --> F[Apply后加载本地状态]3.3 游戏后端服务容器化部署中Go二进制体积与启动时延的工程权衡
在高并发、低延迟要求的游戏后端场景中，Go 服务容器镜像的构建策略直接影响冷启动响应（如匹配服扩容）和资源密度。
编译优化对体积与启动的影响
启用 CGO_ENABLED=0 并结合 -ldflags 剪裁调试信息可显著压缩体积：
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 \
go build -a -ldflags="-s -w -buildid=" -o game-match main.go-s -w：剥离符号表与调试信息（体积↓30–50%，启动加载快约12–18ms）；-buildid=：禁用构建ID嵌入，避免镜像层不可复现；CGO_ENABLED=0：避免动态链接 libc，确保静态二进制兼容性（但禁用net包 DNS 解析优化需额外处理）。
权衡决策矩阵
| 策略 | 二进制体积 | 启动时延 | 容器镜像大小 | 调试能力 |
|---|---|---|---|---|
| 默认编译 | ~18 MB | 42 ms | ~22 MB（含 alpine 基础层） | 完整 |
-s -w + 静态链接 |
~9 MB | 28 ms | ~13 MB | 无符号栈回溯 |
| UPX 压缩（不推荐） | ~3 MB | 65 ms（解压开销） | ~7 MB | 完全失效 |
启动路径关键路径分析
graph TD
A[容器 runtime fork] --> B[加载 ELF 段]
B --> C[解析 .dynamic / .got.plt]
C --> D[执行 _rt0_amd64_linux]
D --> E[初始化 runtime.mheap / net.Resolver]
E --> F[main.main]生产环境统一采用 CGO_ENABLED=0 -ldflags="-s -w"，在启动时延与可观测性间取得确定性平衡。
第四章：新兴及垂直领域游戏公司的Go语言创新应用
4.1 独立工作室：使用Go快速构建轻量级匹配中台与DevOps流水线一体化实践
独立工作室需在资源受限下兼顾开发敏捷性与系统可靠性。我们基于 Go 构建单二进制匹配中台，内嵌 HTTP API、任务调度与 GitOps 驱动的部署引擎。
核心服务启动逻辑
func main() {
cfg := config.Load("config.yaml") // 加载含匹配规则、K8s上下文、Webhook密钥的配置
srv := match.NewServer(cfg) // 初始化匹配引擎（支持LRU缓存+权重轮询）
srv.RegisterDevOpsPipeline( // 内置CI/CD钩子：PR合并→构建→灰度匹配规则热加载
gitlab.NewClient(cfg.GitLab.Token),
k8s.NewDynamicClient(cfg.KubeConfig),
)
srv.Start(":8080") // 启动时自动校验规则语法并预热匹配索引
}config.Load() 解析 YAML 中的 match.rules（JSON Schema 校验）、devops.webhook.secret（用于签名验证）和 k8s.namespace；RegisterDevOpsPipeline 将 Git 事件映射为原子化匹配策略更新操作，避免重启。
匹配中台与流水线协同流程
graph TD
A[GitLab PR Merge] --> B[Webhook触发]
B --> C{YAML规则校验}
C -->|通过| D[热更新内存规则树]
C -->|失败| E[拒绝部署 + Slack告警]
D --> F[匹配请求实时生效]关键能力对比
| 能力 | 传统方案 | 本Go一体方案 |
|---|---|---|
| 规则变更生效延迟 | ≥2分钟（重建+发布） | |
| 二进制体积 | ~300MB（含JVM） | ~12MB（静态链接） |
| DevOps链路断点 | 4+独立服务 | 单进程内闭环 |
4.2 Web3游戏项目：Go语言在链游匹配合约监听与事件驱动架构中的角色定位
事件监听器核心结构
Go凭借高并发协程与原生channel，天然适配EVM事件流处理。以下为监听匹配事件的轻量级封装：
// 监听GameMatched事件并触发玩家配对逻辑
func ListenMatchEvents(client *ethclient.Client, contractAddr common.Address) {
contract, _ := game.NewGameContract(contractAddr, client)
logs := make(chan types.Log, 100)
sub, err := client.SubscribeFilterLogs(context.Background(),
ethereum.FilterQuery{
Addresses: []common.Address{contractAddr},
Topics: [][]common.Hash{{game.GameMatchedTopic}}, // 匹配事件签名哈希
}, logs)
if err != nil { panic(err) }
go func() {
for log := range logs {
matchEvent, err := contract.ParseGameMatched(log) // 解析链上日志
if err == nil {
go handlePlayerPairing(matchEvent.PlayerA, matchEvent.PlayerB) // 异步配对调度
}
}
}()
}ParseGameMatched基于ABIGen生成的绑定代码，将原始log.Data按ABI规范反序列化为结构体；Topics字段精准过滤目标事件，避免全量日志拉取开销。
架构优势对比
| 维度 | Node.js（WebSockets） | Go（EthClient + Goroutines） |
|---|---|---|
| 并发吞吐 | 单线程事件循环瓶颈 | 轻量协程（≤10KB栈）百万级连接 |
| 内存占用 | V8堆内存波动大 | 确定性GC+对象池复用 |
| 故障隔离 | 全局异常中断监听 | 单goroutine崩溃不影响其他流 |
数据同步机制
- 采用“区块头轮询 + 日志回溯”双保险策略，确保事件不丢失
- 每次监听启动时自动校验最新区块号，补全未处理的历史事件
- 所有配对结果通过Redis Stream持久化，供匹配引擎实时消费
graph TD
A[以太坊节点] -->|Log Filter| B(Go事件监听器)
B --> C[解析GameMatched]
C --> D[goroutine池分发]
D --> E[Redis Stream写入]
E --> F[匹配服务消费]4.3 云游戏平台：Go在边缘节点匹配代理服务中的零拷贝网络栈与资源隔离实现
云游戏低延迟诉求倒逼边缘匹配代理重构I/O路径。Go原生net.Conn默认启用内核缓冲区拷贝，成为瓶颈。
零拷贝优化路径
- 使用
golang.org/x/sys/unix直接调用splice()系统调用 - 基于
io.CopyBuffer定制ZeroCopyConn封装体 - 禁用
Read/Write缓冲，绕过bufio中间层
核心零拷贝连接封装
func (c *ZeroCopyConn) Write(p []byte) (n int, err error) {
// splice(fd_in, nil, fd_out, nil, len(p), SPLICE_F_NONBLOCK)
n, err = unix.Splice(int(c.fd), nil, int(c.peerFD), nil, len(p), 0)
return
}unix.Splice在内核空间直连pipe buffer，避免用户态内存拷贝；peerFD为已建立的UDP socket或AF_UNIX域套接字，标志位禁用阻塞等待。
资源隔离维度
| 维度 | 实现方式 |
|---|---|
| CPU | runtime.LockOSThread()绑定P |
| 内存 | mmap(MAP_HUGETLB)大页分配 |
| 网络带宽 | eBPF TC classifier限速 |
graph TD
A[客户端UDP包] --> B{ZeroCopyConn}
B --> C[splice→kernel pipe]
C --> D[AF_UNIX peerFD]
D --> E[匹配引擎goroutine池]4.4 模拟经营类厂商：Go语言支撑长周期在线状态服务的持久化会话管理设计
模拟经营类游戏需维持数天乃至数周的玩家在线状态，传统内存会话易因重启丢失。Go 语言凭借高并发协程与强类型系统，成为构建可靠持久化会话层的理想选择。
核心设计原则
- 会话状态分层存储：热数据（如建筑建造倒计时）驻留 Redis；冷数据（如资源累计日志）异步落盘至 PostgreSQL
- 自动续期机制：每次玩家操作触发
TTL延长，避免误踢出 - 会话快照压缩：使用 Protocol Buffers 序列化，体积减少 62%
数据同步机制
// SessionManager.RefreshWithSnapshot 刷新会话并生成增量快照
func (sm *SessionManager) RefreshWithSnapshot(sid string, delta *pb.SessionDelta) error {
// 使用 Lua 脚本保证 Redis 原子性：读旧值 → 合并 delta → 写新值 → 更新 TTL
script := redis.NewScript(`
local old = redis.call('HGETALL', KEYS[1])
local merged = merge_tables(old, ARGV[1]) -- 自定义合并逻辑
redis.call('HMSET', KEYS[1], unpack(merged))
redis.call('EXPIRE', KEYS[1], tonumber(ARGV[2]))
return 1
`)
return script.Run(ctx, sm.rdb, []string{sid}, delta.String(), "86400").Err()
}该函数确保会话更新的原子性与一致性；delta.String() 提供二进制增量而非全量传输；86400 为默认 24 小时 TTL，单位秒。
| 组件 | 作用 | SLA |
|---|---|---|
| Redis Cluster | 热状态读写（ | 99.99% |
| PostgreSQL | 快照归档与审计追溯 | 99.95% |
| Go Worker Pool | 异步刷盘与过期清理 | 无超时 |
graph TD
A[客户端操作] --> B[API Server /session/refresh]
B --> C[SessionManager.RefreshWithSnapshot]
C --> D{Lua 原子脚本}
D --> E[Redis 更新+TTL 延长]
D --> F[触发异步刷盘任务]
F --> G[PostgreSQL 归档]第五章：哪些公司可以用go语言
Go语言凭借其简洁语法、卓越的并发模型、快速编译和原生跨平台能力，已成为现代云原生基础设施与高并发服务的事实标准之一。它并非仅适用于“初创公司”或“小团队”，而是被全球不同规模、不同行业的头部企业深度集成进核心生产系统。
云服务与基础设施厂商
Google作为Go语言的诞生地，早已将Go用于Borg调度器后续演进系统（如Kubernetes控制平面组件kube-apiserver、etcd v3客户端）、内部微服务网关及GCP多项托管服务。AWS在Lambda运行时管理、EKS底层节点代理（eks-node-agent）及CLI工具aws-cli v2中大量采用Go；Cloudflare使用Go重构其边缘规则引擎，单节点QPS超200万，平均延迟低于3ms。
金融科技企业
PayPal在2018年将核心支付路由服务从Java迁移至Go，服务启动时间从12秒降至400毫秒，GC停顿减少92%，运维容器密度提升3.7倍。Stripe用Go构建实时风控决策流（Real-time Risk Scoring Pipeline），处理每秒15,000+交易请求，通过net/http+gorilla/mux+自研限流中间件实现亚毫秒级P99延迟。中国某头部券商的期权做市系统后端全部基于Go开发，依托gRPC-Gateway统一暴露REST/gRPC双协议，对接FPGA行情加速卡驱动层。
内容平台与社交应用
Twitch在2020年将聊天消息分发系统（Chat Relay）重写为Go，利用sync.Map与chan组合构建无锁广播队列，支撑峰值500万并发连接；其直播推流元数据同步服务使用Go+Redis Streams实现跨区域强一致状态同步。Discord将语音服务器信令模块迁移至Go，借助context包实现毫秒级请求取消传播，错误率下降68%。
开源项目生态支撑力
| 公司/组织 | 代表Go项目 | 生产场景 |
|---|---|---|
| Kubernetes社区 | kubelet, controller-manager | 每日调度超10亿Pod实例 |
| HashiCorp | Terraform CLI, Vault server | 基础设施即代码执行引擎与密钥管理中枢 |
| Cloud Native CI/CD | Tekton Pipelines, Argo CD | 多租户GitOps持续交付流水线 |
flowchart LR
A[用户HTTP请求] --> B{Go HTTP Server}
B --> C[JWT鉴权中间件]
C --> D[goroutine池分发]
D --> E[并行调用gRPC微服务]
E --> F[etcd分布式锁协调]
F --> G[响应流式推送]Docker Engine自v1.11起完全用Go重写，其容器生命周期管理、镜像分层存储（graphdriver）、网络插件（libnetwork）均基于Go标准库os/exec、archive/tar与net包深度定制；国内某短视频平台将推荐系统AB实验分流网关替换为Go实现，CPU占用降低41%，支持动态热加载Lua规则脚本，日均处理实验流量12TB。Netflix虽以JVM生态为主，但其开源的微服务治理工具Prana（Sidecar模式）及部分边缘缓存预热服务亦采用Go构建，验证其在混合技术栈中的无缝嵌入能力。GitHub Actions Runner客户端使用Go编写，可原生编译为Windows/macOS/Linux三端二进制，无需运行时依赖。
