第一章：Go认证服务的高并发瓶颈全景图
在千万级用户规模的在线平台中，基于JWT或Session的Go认证服务常成为系统吞吐量的“隐形断点”。当QPS突破3000时，典型表现包括goroutine堆积、内存分配陡增、Redis连接池耗尽及HTTP延迟P95飙升至800ms以上。这些现象并非孤立发生，而是由多个耦合瓶颈共同作用的结果。
认证路径中的关键阻塞点
- 密码校验环节：bcrypt.CompareHashAndPassword默认使用cost=14，在单核上耗时约120ms，高并发下极易形成goroutine排队；
- Token签发与验证：RSA签名运算（如RS256）在无硬件加速时CPU密集，而频繁调用time.Now()生成iat/exp字段会触发时间系统锁争用；
- 存储层交互：每次登录/刷新均需访问Redis（黑名单校验）+ PostgreSQL（用户状态/权限同步），跨服务RTT叠加导致P99延迟恶化。
典型性能压测数据对比（单节点，4c8g）
| 场景 | 平均QPS | P95延迟 | goroutine峰值 | 内存增长/分钟 |
|---|---|---|---|---|
| 原生bcrypt + 同步Redis | 2100 | 620ms | 18,400 | +142MB |
| scrypt替代bcrypt + 连接池复用 | 4800 | 190ms | 7,200 | +38MB |
| JWT预签名缓存 + 异步黑名单同步 | 7600 | 85ms | 4,100 | +12MB |
关键优化验证步骤
启动pprof分析定位热点：
# 在认证服务中启用pprof（确保已导入 _ "net/http/pprof"）
curl -s "http://localhost:6060/debug/pprof/goroutine?debug=2" | grep -A 10 "bcrypt"
# 输出将显示大量goroutine阻塞在runtime.semasleep，印证密码校验为调度瓶颈进一步通过go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30采集CPU profile，可确认crypto/rsa.(*PrivateKey).Sign与golang.org/x/crypto/bcrypt.hash合计占用超65% CPU时间。此时应优先引入密钥预加载、哈希算法降级（如Argon2id with reduced iterations）及令牌验证路径的零拷贝解析优化。
第二章：goroutine泄漏的根因定位与实战修复
2.1 goroutine生命周期管理的理论模型与pprof可视化验证
goroutine 的生命周期可抽象为：创建 → 就绪 → 运行 → 阻塞/休眠 → 完成/销毁五个核心状态，其转换受调度器（M:P:G 模型）与运行时系统协同控制。
数据同步机制
阻塞态 goroutine 常因 channel 操作、锁竞争或系统调用而触发状态迁移。以下示例展示典型阻塞场景：
func blockingExample() {
ch := make(chan int, 1)
go func() {
time.Sleep(100 * time.Millisecond) // 模拟耗时任务
ch <- 42 // 唤醒接收方
}()
<-ch // 此处 goroutine 进入 Gwaiting 状态
}<-ch 导致当前 goroutine 进入 Gwaiting 状态，被挂起并加入 channel 的等待队列；ch <- 42 触发唤醒逻辑，调度器将其重新置入 runqueue。
pprof 验证路径
启用 net/http/pprof 后，可通过 /debug/pprof/goroutine?debug=2 获取带栈帧的完整 goroutine 快照，识别长期阻塞或泄漏实例。
| 状态标识 | pprof 输出关键词 | 含义 |
|---|---|---|
running |
running |
正在 M 上执行 |
chan receive |
semacquire |
等待 channel 接收 |
IO wait |
epollwait |
系统调用阻塞中 |
graph TD
A[New] --> B[Runnable]
B --> C[Running]
C --> D[Blocked/Waiting]
D -->|channel ready\|timer fired| B
C --> E[Dead]2.2 认证中间件中context超时未传播导致的goroutine悬停复现
问题现象
当 HTTP 请求携带 context.WithTimeout 进入认证中间件，但中间件未将该 context 传递至下游 goroutine（如 token 校验协程），会导致子 goroutine 永久阻塞。
复现代码片段
func authMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)
defer cancel() // ⚠️ 仅取消父ctx，不传播！
go func() {
time.Sleep(1 * time.Second) // 模拟耗时校验
log.Println("token validated") // 永远不会执行（悬停）
}()
next.ServeHTTP(w, r)
})
}逻辑分析：go func() 内部未接收或使用 ctx，无法响应 Done() 信号；cancel() 仅作用于父 context，子 goroutine 无感知，形成不可回收的悬停。
关键修复原则
- 所有衍生 goroutine 必须显式接收并监听
ctx.Done() - 中间件需透传 context，而非仅创建新 context
| 错误模式 | 正确做法 |
|---|---|
go doWork() |
go doWork(ctx) |
defer cancel() 后启动 goroutine |
go doWork(ctx) + select { case <-ctx.Done(): return } |
2.3 JWT解析阶段阻塞I/O未封装为异步任务引发的泄漏链分析
当JWT解析需同步读取密钥文件（如 PEM）或远程 JWKS 端点时，若未显式调度至 asyncio.to_thread() 或线程池，将直接阻塞事件循环。
关键泄漏路径
- 主协程被阻塞 → 事件循环停滞 → 其他请求积压 → 连接超时 → 连接池耗尽 → 资源泄漏雪崩
同步解析的典型反模式
# ❌ 危险：阻塞式文件读取，在协程中直接调用
with open("/etc/jwt/pubkey.pem", "r") as f: # ⚠️ 阻塞 I/O，冻结整个 event loop
pubkey = f.read()
decoded = jwt.decode(token, pubkey, algorithms=["RS256"])此处
open()是同步系统调用，无法被asyncio暂停/让出；在高并发场景下，单次解析可导致数百请求排队等待。
修复方案对比
| 方式 | 是否异步安全 | 适用场景 | 风险提示 |
|---|---|---|---|
asyncio.to_thread(open, ...) |
✅ | Python ≥3.9，短IO | 需捕获 FileNotFoundError |
aiofiles.open(...) |
✅ | 长期维护项目 | 额外依赖，PEP 594 尚未弃用 |
graph TD
A[收到JWT验证请求] --> B{是否调用阻塞I/O？}
B -->|是| C[事件循环冻结]
C --> D[待处理协程积压]
D --> E[连接超时/重试放大]
B -->|否| F[正常异步调度]2.4 基于runtime.Stack与gops工具的线上goroutine快照比对实践
线上 goroutine 泄漏常表现为 Goroutines 数量持续增长。精准定位需两次快照比对：一次基线，一次异常时刻。
快照采集方式对比
| 方式 | 触发方式 | 是否阻塞 | 输出粒度 |
|---|---|---|---|
runtime.Stack |
Go 程序内调用 | 是（全局停顿） | 全量栈帧文本 |
gops stack |
外部信号触发 | 否 | 按 PID 过滤 |
使用 runtime.Stack 生成快照
func dumpGoroutines(filename string) error {
buf := make([]byte, 1024*1024)
n := runtime.Stack(buf, true) // true: 打印所有 goroutine；false: 仅当前
return os.WriteFile(filename, buf[:n], 0644)
}runtime.Stack(buf, true) 将所有 goroutine 的调用栈写入缓冲区；true 参数启用全量模式，适用于泄漏初筛。
gops 实时比对流程
graph TD
A[启动 gops agent] --> B[获取 baseline.stack]
B --> C[触发业务压测]
C --> D[获取 peak.stack]
D --> E[diff -u baseline.stack peak.stack]分析技巧
- 优先过滤
runtime.gopark、select、chan receive等阻塞态 goroutine； - 关注重复出现但未退出的自定义协程名（如
worker#123）； - 结合
gops stats查看Goroutines计数趋势。
2.5 泄漏防护模式：带CancelFunc的Worker Pool + 限流熔断双校验机制
核心设计思想
将 Goroutine 生命周期与上下文取消深度绑定，同时在任务准入层叠加速率控制（令牌桶）与健康度判断（熔断器状态）。
双校验准入流程
func (p *WorkerPool) Submit(ctx context.Context, job Job) error {
// 1. 熔断器快速拒绝（非阻塞）
if !p.circuit.IsAllowed() {
return ErrCircuitOpen
}
// 2. 限流器尝试获取令牌
if !p.limiter.Allow() {
return ErrRateLimited
}
// 3. 绑定可取消上下文并投递
return p.workers <- func() { job.Run(withCancel(ctx)) }
}withCancel(ctx)：包装原始 ctx，生成带CancelFunc的子上下文，确保 Worker 异步执行时可被统一终止；p.circuit.IsAllowed()：无锁读取熔断器状态（closed/half-open/open），毫秒级响应；p.limiter.Allow()：原子扣减令牌，失败立即返回，不排队。
校验优先级对比
| 校验项 | 触发时机 | 开销 | 失败影响 |
|---|---|---|---|
| 熔断检查 | 最先 | O(1) | 拒绝全部新请求 |
| 限流检查 | 次之 | ~O(1) | 拒绝超额请求 |
graph TD
A[Submit Job] --> B{熔断器允许？}
B -- 否 --> C[ErrCircuitOpen]
B -- 是 --> D{令牌桶可用？}
D -- 否 --> E[ErrRateLimited]
D -- 是 --> F[派发至Worker + CancelFunc绑定]第三章：Redis Pipeline在认证场景下的误用陷阱
3.1 Pipeline原子性假象与认证请求幂等性冲突的理论推演
Pipeline 在分布式系统中常被建模为“原子操作”，但实际由多个异步阶段（如鉴权、路由、签名验证）组成，各阶段失败重试策略不一，导致逻辑原子性与物理可重入性根本矛盾。
认证请求的幂等性边界
- OAuth2 Token 刷新请求天然幂等（
client_id + scope + grant_type唯一标识） - 但 Pipeline 中若在
verify_signature → validate_nonce → issue_token链路中途重试，nonce可能被重复消费
关键冲突点：状态跃迁不可逆性
# 伪代码：带状态检查的 nonce 消费
def consume_nonce(nonce: str, ttl: int = 300) -> bool:
# 1. 尝试 SETNX + EXPIRE（原子组合）
if redis.set(nonce, "used", nx=True, ex=ttl):
return True
# 2. 若已存在，说明已被其他 pipeline 实例处理过
raise NonceAlreadyConsumedError(nonce)该函数依赖 Redis 的 SETNX 原子性，但 Pipeline 若在 consume_nonce() 返回前崩溃（如网络超时），上游可能重发请求——而下游已持久化 nonce 状态，造成认证拒绝而非静默幂等通过。
冲突本质对比表
| 维度 | Pipeline 原子性假象 | 认证幂等性要求 |
|---|---|---|
| 状态一致性模型 | 最终一致（多阶段异步） | 强一致（nonce 单次有效） |
| 失败恢复行为 | 重试整个链路 | 必须识别并跳过已处理请求 |
graph TD
A[Client 发起 /token 请求] --> B{Pipeline 入口}
B --> C[verify_signature]
C --> D[validate_nonce]
D -->|成功| E[issue_token]
D -->|失败| F[500 Internal Error]
F --> G[Client 重试]
G --> B
D -->|并发重试| H[redis.set nx=False → 失败]
H --> I[抛出 NonceAlreadyConsumedError]3.2 Token续期批量操作中Pipeline+WATCH混合使用导致的CAS失效实测
问题复现场景
在高并发Token续期任务中，采用Pipeline批量执行GET + SETEX，同时对last_refresh_ts字段使用WATCH实现乐观锁——但实际观察到多个客户端成功写入同一过期时间，CAS语义被绕过。
根本原因分析
Redis 的 WATCH 仅对后续 EXEC 命令生效，而 Pipeline 中若未显式调用 multi()/exec()，WATCH 监控将被忽略；更关键的是：Pipeline 默认非事务模式，WATCH 与 Pipeline 混用时监控完全失效。
# ❌ 错误用法：WATCH 在 pipeline 中不生效
pipe = redis.pipeline()
pipe.watch("token:123:last_refresh_ts")
pipe.get("token:123:ttl") # WATCH 不作用于 pipeline 中的 get
pipe.setex("token:123:ttl", 3600, new_val) # 无CAS保护
pipe.execute() # WATCH 被静默丢弃⚠️ 参数说明：
pipe.watch()必须紧邻pipe.multi()调用，且所有受保护操作需在multi()之后、execute()之前；否则 WATCH 失效，退化为裸写。
正确实践对比
| 方式 | 是否保证CAS | 适用场景 |
|---|---|---|
单命令 SET key val EX 3600 NX |
✅ 原子性保障 | 简单续期 |
WATCH+MULTI+EXEC（非pipeline） |
✅ 严格乐观锁 | 复杂条件判断 |
Pipeline+WATCH |
❌ 监控丢失 | 应避免 |
graph TD
A[客户端发起续期] --> B{是否使用WATCH+PIPELINE？}
B -->|是| C[WATCH被Pipeline忽略]
B -->|否| D[进入MULTI事务块]
C --> E[并发写入冲突→CAS失效]
D --> F[EXEC触发WATCH校验→失败回滚]3.3 连接池竞争下Pipeline命令堆积引发的Redis响应延迟雪崩复现
当高并发场景中连接池资源紧张时，客户端频繁复用有限连接提交 Pipeline 请求，易导致命令在 socket 缓冲区或 Redis 客户端队列中堆积。
堆积触发条件
- 连接池最大连接数
maxActive=8 - 单次 Pipeline 批量
128条命令 - 并发线程数
>20
关键复现代码
// 使用 JedisPool 提交高密度 Pipeline
try (Jedis jedis = pool.getResource()) {
Pipeline p = jedis.pipelined();
for (int i = 0; i < 128; i++) {
p.get("key:" + i); // 非阻塞入队，但实际未发送
}
p.sync(); // 此处阻塞等待响应，若连接被抢占则排队加剧
}p.sync() 强制刷写并同步等待，若底层连接正被其他线程持有（如慢查询阻塞），该调用将卡在 SocketOutputStream.write()，引发级联等待。
延迟传播路径
graph TD
A[线程T1调用sync] --> B{连接是否空闲？}
B -- 否 --> C[进入连接获取等待队列]
C --> D[后续Pipeline请求持续入队]
D --> E[内核socket send buffer满]
E --> F[RTT指数级上升 → 雪崩]| 指标 | 正常值 | 雪崩阈值 |
|---|---|---|
| avg. pipeline RTT | 1.2 ms | > 200 ms |
| 连接池等待率 | > 65% |
第四章：双故障耦合效应的建模与协同治理
4.1 goroutine泄漏 × Pipeline阻塞的QPS拐点数学建模（含P99延迟公式）
当 pipeline 阶段因下游消费滞后持续缓存结果，未被 range 消费的 channel 发送端 goroutine 将永久阻塞——形成泄漏。
goroutine泄漏典型模式
func leakyPipeline(in <-chan int) <-chan int {
out := make(chan int)
go func() {
for v := range in { // 若 out 无人接收，此 goroutine 永不退出
out <- v * 2 // 阻塞在此，goroutine 泄漏
}
close(out)
}()
return out
}逻辑分析：out 为无缓冲 channel，若消费者提前退出或速率不足，out <- v * 2 永久挂起；该 goroutine 占用栈+调度资源，数量随请求线性增长。
QPS拐点与P99延迟模型
设单阶段处理耗时均值 μ、标准差 σ，N级pipeline在阻塞阈值B下，P99延迟近似为：
$$D_{99} \approx \mu N + \sigma N^{0.8} + \frac{QPS}{B – QPS} \cdot \mu$$
拐点发生在 $QPS \to B$ 时分母趋零，延迟爆炸式上升。
| QPS | B=1000 | P99延迟(ms) |
|---|---|---|
| 800 | ✅ | 42 |
| 950 | ⚠️ | 317 |
| 990 | ❌ | >2100 |
阻塞传播路径
graph TD
A[Client QPS↑] --> B[Stage1 goroutine↑]
B --> C{out chan buffer full?}
C -->|Yes| D[Stage1 send block]
C -->|No| E[Normal flow]
D --> F[Stage2 consumer lag ↑]
F --> B4.2 基于eBPF的Go runtime与Redis客户端协程级联动追踪实践
为实现Go协程（goroutine）与Redis客户端调用的精准关联，我们利用eBPF在runtime.govcall和net/http.(*Client).Do入口处埋点，并通过bpf_get_current_pid_tgid()与bpf_get_current_comm()捕获协程ID（GID）及进程上下文。
数据同步机制
采用环形缓冲区（perf_event_array）传递事件，结构体包含：
goroutine_id（从runtime.goid提取）redis_cmd（命令名，如GET/SET）latency_ns（纳秒级耗时）
// eBPF程序片段：捕获Redis命令执行起点
SEC("tracepoint/syscalls/sys_enter_connect")
int trace_redis_connect(struct trace_event_raw_sys_enter *ctx) {
u64 pid_tgid = bpf_get_current_pid_tgid();
u32 pid = pid_tgid >> 32;
struct event_t event = {};
event.goroutine_id = get_goroutine_id(pid); // 自定义辅助函数
bpf_probe_read_user(&event.redis_cmd, sizeof(event.redis_cmd),
(void*)ctx->args[2]); // args[2]为addr指针，需二次读取
bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &event, sizeof(event));
return 0;
}逻辑分析：该eBPF探针挂载在
connect()系统调用入口，间接标识Redis连接建立阶段；get_goroutine_id()通过遍历当前进程的Go runtime状态获取活跃GID；bpf_probe_read_user()安全读取用户态内存中的命令地址，避免越界访问。参数ctx->args[2]对应struct sockaddr*，实际命令需结合Go Redis client（如github.com/go-redis/redis/v9）的socket绑定行为动态推断。
关联建模维度
| 维度 | 来源 | 用途 |
|---|---|---|
| Goroutine ID | Go runtime symbol | 标识协程生命周期 |
| Trace ID | OpenTelemetry ctx | 跨服务链路对齐 |
| Redis Addr | getpeername() syscall |
定位目标实例与分片 |
graph TD
A[Go应用] -->|goroutine_start| B[eBPF tracepoint: go:sched:goroutine:create]
B --> C{匹配Redis调用栈？}
C -->|是| D[eBPF kprobe: net.Conn.Write]
C -->|否| E[丢弃]
D --> F[perf buffer → 用户态解析器]
F --> G[关联GID + CMD + LATENCY]4.3 认证服务熔断降级策略：Token本地缓存+Redis降级读写分离方案
当认证服务不可用时，系统需保障用户会话连续性。核心思路是：写操作熔断，读操作降级为多级缓存兜底。
降级读路径设计
- 优先查本地 Caffeine 缓存（TTL=5min，maxSize=10000）
- 本地未命中则查 Redis（主从分离，仅读从节点）
- Redis 失败后允许有限次 JWT 本地验签（无须远程调用）
数据同步机制
// 降级写入仅记录日志，不触发Redis写
if (circuitBreaker.isInOpenState()) {
log.warn("Auth service down, skip Redis write for token: {}", tokenId);
return; // 熔断期间禁止写Redis，避免雪崩
}逻辑分析：isInOpenState() 基于 Hystrix 或 Resilience4j 的失败率阈值（默认50%失败/10s内20次）；跳过写操作可防止下游Redis积压与连接耗尽。
| 组件 | 读角色 | 写角色 | 降级响应时间 |
|---|---|---|---|
| Caffeine | ✅ | ❌ | |
| Redis Slave | ✅ | ❌ | ~5ms |
| JWT 本地验签 | ✅ | ❌ |
graph TD A[Token验证请求] –> B{Circuit Open?} B — Yes –> C[查Caffeine] C –> D{Hit?} D — No –> E[查Redis Slave] D — Yes –> F[返回认证结果] E –> G{Success?} G — No –> H[JWT本地验签] G — Yes –> F
4.4 故障注入测试框架设计：Chaos Mesh模拟goroutine堆积+Pipeline超时双扰动
为精准复现高并发场景下的级联故障，我们基于 Chaos Mesh 设计双扰动协同注入策略。
双扰动协同机制
- goroutine 堆积：通过
StressChaos持续调用runtime.Gosched()并阻塞 I/O，触发调度器过载； - Pipeline 超时：利用
NetworkChaos注入delay+loss，使 gRPC 流式响应延迟突破3s熔断阈值。
核心配置示例
# chaos-mesh-double-disturbance.yaml
apiVersion: chaos-mesh.org/v1alpha1
kind: StressChaos
metadata:
name: goroutine-stress
spec:
mode: one
selector:
namespaces: ["prod"]
stressors:
cpu: {} # 触发 GC 频繁、P 绑定失衡，间接堆积 goroutine该配置不直接创建 goroutine，而是通过 CPU 压力迫使 runtime 延迟调度、扩大
allg队列长度，符合 Go 调度器实际堆积路径；mode: one避免多 Pod 同时扰动导致噪声放大。
扰动组合效果对比
| 扰动类型 | P99 延迟 | goroutine 数量增幅 | Pipeline 失败率 |
|---|---|---|---|
| 单 goroutine 堆积 | 1.2s | +380% | 12% |
| 双扰动协同 | 4.7s | +410% | 89% |
graph TD
A[Chaos Mesh Controller] --> B{注入调度器压力}
A --> C{注入网络延迟/丢包}
B & C --> D[goroutine 队列膨胀]
D --> E[net/http.serverHandler.ServeHTTP 阻塞]
E --> F[Pipeline context.DeadlineExceeded]第五章：从丢Token到SLA可承诺的工程演进路径
在2023年Q3，某千万级日活SaaS平台遭遇了一次典型的“丢Token”雪崩事件：用户登录后频繁被强制登出，移动端错误率飙升至37%，客服工单量单日突破1.2万。根本原因并非JWT签名失效，而是Redis集群中user_session:xxx键因过期策略与写入竞争出现非原子性丢失——旧Token未被显式删除，新Token写入时因Pipeline批量操作中断而部分失败，导致客户端持有已失效Token却无法刷新。
会话状态治理的三阶段跃迁
初期采用纯无状态JWT方案，但忽略设备指纹绑定与异常登出场景；中期引入Redis缓存Token元数据，却未实现DEL + SETEX的Lua原子封装；最终落地双写一致性协议：所有Token签发/吊销均通过统一网关调用session-manager服务，该服务内部使用Redlock+TTL续约机制，并将操作日志实时同步至Kafka供审计追踪。
SLA量化反推架构改造清单
| 指标项 | 当前值 | 目标SLA | 工程动作 |
|---|---|---|---|
| Token续期P99延迟 | 420ms | ≤80ms | 将Session TTL校验下沉至边缘节点，仅主中心校验黑名单 |
| 强制登出生效时间 | ≤9.2s | ≤1.5s | 构建基于Pub/Sub的实时广播通道，替代轮询黑名单 |
| 会话一致性故障率 | 0.037% | ≤0.001% | 在API网关层注入幂等Session ID，拦截重复Token提交 |
flowchart LR
A[客户端发起Token刷新] --> B{网关校验Session ID是否重复}
B -->|是| C[返回409 Conflict]
B -->|否| D[调用session-manager服务]
D --> E[执行Lua脚本：DEL old_key + SETEX new_key 3600]
E --> F[向Kafka推送session_revoke_event]
F --> G[边缘节点消费事件并更新本地黑名单]灰度发布中的熔断验证
在灰度集群部署新会话模块后，通过Chaos Mesh注入网络分区故障：模拟Redis主从同步延迟达8s。监控发现旧版本服务因等待WAIT 1 5000命令超时直接返回500，而新版本启用降级策略——当Redis响应超300ms时，自动切换至本地Caffeine缓存（预热最近10分钟活跃Session），保障99.2%请求仍可完成Token续期。该策略经72小时压测验证，在99.99%流量下维持P95延迟
生产环境Token生命周期看板
运维团队构建了全链路追踪看板，聚合来自OpenTelemetry的Span数据：从OAuth2授权码兑换、JWT签发、Redis写入、CDN边缘缓存、到客户端存储时长。当发现某Android机型Token平均存活时长仅1.8小时（远低于设定的24小时），定位到厂商ROM对WebView Cookie清理策略激进，随即推动客户端SDK改用EncryptedSharedPreferences持久化Token元数据，并增加后台心跳保活逻辑。
合同级SLA的技术锚点
客户合同中约定“会话连续性可用率≥99.95%”，技术团队将其拆解为可测量的原子指标：单次Token刷新成功率≥99.999%、跨区域会话同步延迟≤200ms、黑名单全局收敛时间≤1.2s。每个指标对应独立探针服务，每分钟向Prometheus上报，告警阈值设置为连续5个周期低于基线值即触发P1事件。
该演进路径并非理论推演，而是伴随37次线上事故复盘、142次配置变更、以及与法务部门联合修订8版SLA附录条款沉淀而成。
