Go数据库连接池雪崩复盘报告（马哥用pgbouncer+go-sql-driver日志还原连接泄漏的5个时间戳证据）

第一章：Go数据库连接池雪崩事件全景概览

数据库连接池雪崩并非理论假设，而是真实发生于高并发微服务场景中的连锁故障：当少量请求因慢查询、网络抖动或下游依赖超时导致连接长时间占用，空闲连接迅速耗尽，新请求被迫排队等待；一旦等待队列溢出或超时触发重试风暴，连接需求呈指数级增长，最终压垮数据库与应用节点。

典型诱因包括：

• 连接池配置失衡（如 MaxOpenConns 过低而 MaxIdleConns 过高，导致复用率下降）
• 缺乏有效的连接获取超时控制（SetConnMaxLifetime 未设或设为0，引发 stale connection 积累）
• SQL 执行未加 context.Context 超时约束，单次查询阻塞整个连接

以下是最小可复现雪崩的 Go 片段（使用 database/sql）：

// ❌ 危险示例：无上下文超时，连接获取无限等待
db, _ := sql.Open("mysql", "user:pass@tcp(127.0.0.1:3306)/test")
db.SetMaxOpenConns(5) // 极小值加剧竞争
db.SetMaxIdleConns(5)

// 若某次查询因锁表阻塞10秒，则后续5个并发请求将全部卡在 db.Query()
rows, err := db.Query("SELECT SLEEP(10)") // 模拟慢查询

正确做法需同时约束连接获取与查询执行：

// ✅ 安全实践：双层超时防护
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

// 在获取连接阶段即超时（默认阻塞，需显式设置）
db.SetConnMaxLifetime(30 * time.Second)
db.SetConnMaxIdleTime(5 * time.Second)

// 查询必须携带 context
rows, err := db.QueryContext(ctx, "SELECT id FROM users WHERE active = ?", true)
if err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        log.Warn("query timeout, connection likely stuck")
    }
}

关键配置参数建议参考下表：

参数	推荐值	说明
MaxOpenConns	2 × CPU核心数 × 预估峰值QPS / 平均查询耗时（秒）	避免过度抢占数据库连接数
MaxIdleConns	Min(10, MaxOpenConns)	平衡复用与内存开销
ConnMaxLifetime	30–60s	强制轮换，规避长连接状态异常
ConnMaxIdleTime	5–10s	及时回收空闲连接，释放资源

雪崩往往始于一个未被监控的慢查询，蔓延于缺乏熔断的重试逻辑，并终结于连接池彻底枯竭——此时日志中高频出现 "sql: database is closed" 或 "context deadline exceeded"，而非直观的数据库错误。

第二章：pgbouncer与go-sql-driver协同日志取证分析

2.1 连接池饱和阈值突破的时序建模与压测复现

连接池饱和并非瞬时事件，而是请求到达率、连接持有时间与回收延迟三者在时间维度上耦合失衡的结果。需构建带时间戳的连接生命周期状态机。

时序建模关键变量

• λ：单位时间新连接请求速率（req/s）
• μ：平均连接释放速率（conn/s），受业务逻辑耗时与连接校验开销影响
• T_idle：连接空闲超时阈值（ms）
• maxPoolSize：硬性上限

压测复现核心逻辑

// 模拟高并发下连接抢占与阻塞累积
ExecutorService executor = Executors.newFixedThreadPool(200);
for (int i = 0; i < 5000; i++) {
    executor.submit(() -> {
        try (Connection conn = dataSource.getConnection()) { // 触发 acquire()
            Thread.sleep(80); // 模拟长事务持有连接
        } catch (SQLException | InterruptedException e) {
            // 记录 acquire timeout 异常
        }
    });
}

该代码强制制造连接争抢：200线程并发发起5000次获取请求，单次持有80ms，远超空闲回收窗口（默认30ms），快速触发HikariPool$PoolInitializationException或Connection acquisition timed out。

饱和判定指标对比

指标	正常态	饱和临界态	触发动作
activeConnections		≥ 95%	启动慢SQL审计
threadsAwaitingConnection	0	> 10	熔断降级开关激活
connectionAcquireMillis		> 200ms	上报P99延迟告警

graph TD
    A[请求抵达] --> B{连接池有空闲?}
    B -->|是| C[分配连接]
    B -->|否| D[加入等待队列]
    D --> E{超时未获连接?}
    E -->|是| F[抛出TimeoutException]
    E -->|否| G[连接释放后唤醒]

2.2 pgBouncer日志中client_idle_timeout触发链的5段关键时间戳提取

pgBouncer在连接空闲超时时，日志中隐含完整的状态跃迁时序。需从单条 closing because of client_idle_timeout 日志反向提取5个精确时间戳。

关键时间点语义解析

• client_start：客户端TCP连接建立时刻（log_connections = on 时记录）
• pool_acquire：该连接首次被分配给后端事务的时间
• last_packet：客户端最后发送有效查询包的时间（log_disconnections = on 可佐证）
• idle_start：连接进入idle状态的精确毫秒级起点（由client_idle_timeout倒推计算）
• close_trigger：日志中明确打印的 closing... 时间戳（系统clock_gettime(CLOCK_MONOTONIC)）

日志解析代码示例

# 从pgbouncer.log提取含client_idle_timeout的行及前后3行上下文
zgrep "client_idle_timeout" /var/log/pgbouncer/pgbouncer.log | \
  awk '{print $1,$2,$3}' | head -n 1 | \
  xargs -I{} date -d "{}" +%s.%3N  # 输出close_trigger时间戳（秒+毫秒）

此命令提取日志首行时间字段并转换为Unix毫秒时间戳，作为触发链终点锚点；%3N确保毫秒精度，避免因日志轮转导致的时序错位。

五段时间戳映射表

时间戳名称	来源方式	精度
client_start	log_connections 日志行	毫秒
pool_acquire	SHOW POOLS 快照 + 连接ID匹配	秒级
last_packet	TCP层抓包或log_packets=on	微秒级
idle_start	close_trigger - client_idle_timeout	毫秒
close_trigger	closing because... 日志时间	毫秒

触发链时序逻辑（mermaid）

graph TD
  A[client_start] --> B[pool_acquire]
  B --> C[last_packet]
  C --> D[idle_start]
  D --> E[close_trigger]
  style D stroke:#f66,stroke-width:2px

2.3 go-sql-driver中sql.Conn.Close()缺失导致连接未归还的堆栈回溯验证

当显式获取 *sql.Conn 后未调用 Close()，连接将滞留于 driverConn 的 inUse 状态，无法归还至连接池。

复现关键代码

conn, err := db.Conn(ctx)
if err != nil {
    log.Fatal(err)
}
// 忘记 conn.Close() → 连接永久占用
rows, _ := conn.QueryContext(ctx, "SELECT 1")
_ = rows.Close()

sql.Conn.Close() 不仅释放底层 driverConn，更会触发 putConn() 调用；缺失时 db.freeConn 队列不增长，db.numOpen 持续累积。

核心调用链验证

调用点	作用
conn.Close()	设置 dc.inUse = false 并调用 db.putConn(dc, err)
db.putConn()	将 dc 推入 db.freeConn 或关闭超时连接
db.openNewConnection()	仅当 freeConn 为空且 < MaxOpen 时新建连接

graph TD
    A[sql.Conn.Close()] --> B[dc.inUse = false]
    B --> C[db.putConn(dc, nil)]
    C --> D{freeConn len < MaxIdle?}
    D -->|是| E[push dc to freeConn]
    D -->|否| F[dc.Close()]

2.4 连接泄漏在runtime/pprof与net/http/pprof中的goroutine泄漏热力图交叉印证

当 HTTP 服务长期运行后出现 goroutine 数量持续攀升，需联动分析两类 pprof 数据源：

数据同步机制

runtime/pprof 捕获实时 goroutine 栈快照（含 net/http.(*conn).serve），而 net/http/pprof 的 /debug/pprof/goroutine?debug=2 提供带 HTTP 路由上下文的可读栈。二者时间戳对齐后可定位阻塞点。

关键诊断代码

// 启用双通道 pprof 并强制同步采样
pprof.StartCPUProfile(os.Stdout) // 触发 runtime 栈采集
http.DefaultServeMux.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))

此处 pprof.Handler("goroutine") 实际调用 runtime.GoroutineProfile()，但添加了 HTTP 请求生命周期标记，使栈中 readLoop/writeLoop 可关联到具体连接 ID。

交叉验证表

指标来源	优势	局限
runtime/pprof	精确到 goroutine 状态	无 HTTP 上下文
net/http/pprof	包含 (*conn).remoteAddr	仅捕获活跃 HTTP 连接

graph TD
  A[HTTP 请求抵达] --> B{net/http.Server.Serve}
  B --> C[启动 (*conn).serve]
  C --> D[runtime.NewGoroutine]
  D --> E[pprof 记录栈帧]
  E --> F[net/http/pprof 添加路由标签]

2.5 基于logrus结构化日志+ELK时间轴对齐的5个证据点精确定位

为实现故障根因的秒级定位，需将 logrus 输出的结构化日志与 ELK（Elasticsearch + Logstash + Kibana）时间轴严格对齐。关键在于统一时间基准、字段语义与事件上下文。

时间戳标准化

logrus 必须禁用本地时区，强制使用 RFC3339 UTC 格式：

log.SetFormatter(&logrus.JSONFormatter{
    TimestampFormat: "2006-01-02T15:04:05.000Z", // 精确到毫秒，Z 表示 UTC
    DisableHTMLEscape: true,
})

→ TimestampFormat 确保日志中 time 字段与 Elasticsearch @timestamp 字段格式完全一致，避免 Logstash date filter 解析偏移。

5类可对齐证据点

• 请求唯一追踪 ID（trace_id）
• 服务名与实例标识（service.name, host.name）
• HTTP 状态码与延迟（http.status_code, latency_ms）
• 错误堆栈摘要（error.kind, error.message）
• 关键业务状态标记（如 order_status: "paid"）

证据点	logrus 字段示例	ELK 中映射类型	对齐作用
请求追踪	"trace_id":"abc123"	keyword	跨服务链路聚合
毫秒级延迟	"latency_ms":42.8	float	性能拐点时间轴锚定

数据同步机制

graph TD
    A[logrus JSON output] --> B[Filebeat tail]
    B --> C[Logstash：date filter + geoip]
    C --> D[Elasticsearch @timestamp]
    D --> E[Kibana Timeline: sync to ms]

第三章：Go原生sql.DB连接池核心机制深度解构

3.1 MaxOpenConns/MaxIdleConns/ConnMaxLifetime三参数联动失效场景推演

失效根源：生命周期与复用策略的时序冲突

当 ConnMaxLifetime = 30s、MaxIdleConns = 5、MaxOpenConns = 10，而业务请求呈脉冲式（每25秒突发8连接并持续10s），空闲连接尚未超龄即被新请求抢占，导致老化连接未被及时清理。

典型代码片段与逻辑分析

db.SetMaxOpenConns(10)
db.SetMaxIdleConns(5)
db.SetConnMaxLifetime(30 * time.Second) // 注意：非ConnMaxIdleTime！

⚠️ 关键误读：ConnMaxLifetime 控制单连接最大存活时长，而非空闲时长；它触发的是连接强制关闭再新建，但若 MaxIdleConns 过小，新连接无法进入idle池，直接走新建路径——绕过idle复用，放大创建/销毁开销。

参数协同失效路径（mermaid）

graph TD
A[请求高峰] --> B{idle池满？}
B -->|是| C[新建连接]
B -->|否| D[复用idle连接]
C --> E[ConnMaxLifetime到期]
E --> F[连接关闭]
F --> G[因MaxIdleConns低，不入idle池]
G --> C

失效组合对照表

参数配置	idle池填充率	老化连接实际回收率	连接泄漏风险
MaxIdle=5, Lifetime=30s		≈40%	中高
MaxIdle=10, Lifetime=30s	>85%	>95%	低

3.2 driver.Conn接口生命周期与sql.driverConn状态机源码级剖析

driver.Conn 是 Go database/sql 包中驱动层的核心抽象，其生命周期严格受 sql.driverConn 状态机管控。

状态迁移核心逻辑

sql.driverConn 内部维护 state 字段（uint32），取值包括：

• idle（空闲，可复用）
• active（正被 Stmt 或 Tx 使用）
• closed（已释放，不可再用）

// src/database/sql/conn.go 中关键状态检查
func (dc *driverConn) releaseConn(err error) {
    if dc.state != idle && dc.state != active {
        return // 忽略非法状态
    }
    atomic.CompareAndSwapUint32(&dc.state, active, idle)
}

该函数仅在 active → idle 时成功切换；若并发调用或状态异常则静默失败，依赖上层 pool 的 putConn 做兜底校验。

状态流转约束表

当前状态	允许转入状态	触发操作
idle	active	conn.prepare()
active	idle	tx.Commit() / stmt.Close()
idle	closed	db.Close() 或超时驱逐

graph TD
    A[idle] -->|acquire| B[active]
    B -->|release| A
    A -->|close| C[closed]
    B -->|forceClose| C

状态机无锁设计依赖 atomic 操作，但 closed 状态不可逆——一旦进入即永久失效，避免资源重复释放。

3.3 context.WithTimeout在QueryContext调用链中被忽略导致连接滞留的实证分析

复现场景关键代码

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
rows, err := db.QueryContext(ctx, "SELECT SLEEP(2)") // 超时应中断，但实际未生效

该调用看似启用超时控制，但若底层驱动未正确响应ctx.Done()信号（如旧版mysql驱动未实现QueryContext接口），则SLEEP(2)将阻塞2秒，连接持续占用。

根本原因分层验证

• 驱动层：database/sql仅传递ctx，不强制校验；
• 实现层：driver.QueryerContext未被实现，回退至Queryer同步接口；
• 连接池：超时上下文未传播至网络I/O层，连接无法主动关闭。

影响对比表

场景	context.WithTimeout生效	连接释放时机	连接池压力
正确实现	✅	查询终止后立即归还	低
驱动忽略ctx	❌	等待SQL执行完成	高（易耗尽）

调用链缺失点示意

graph TD
    A[QueryContext] --> B{驱动是否实现<br>QueryerContext?}
    B -->|是| C[ctx传递至net.Conn.Read]
    B -->|否| D[降级为Query<br>ctx被完全忽略]
    D --> E[连接滞留直至SQL完成]

第四章：高可用数据库中间件协同治理实践

4.1 pgbouncer in transaction模式与Go连接池语义冲突的规避配置方案

核心冲突根源

Go database/sql 连接池默认复用连接并隐式管理事务生命周期，而 PgBouncer 的 transaction 模式在事务结束后立即归还连接——导致 Go 客户端可能在已归还的连接上执行 Commit() 或 Rollback()，触发 pq: server closed the connection unexpectedly 错误。

关键配置组合

• 设置 pool_max_conns = 0（禁用 PgBouncer 自身连接池）
• 启用 ignore_startup_parameters = extra_float_digits（避免会话级参数污染）
• 强制 Go 应用层使用 pgxpool.Config.MaxConns = 10 统一管控

推荐 PgBouncer 配置片段

[databases]
mydb = host=pg host_addr=10.0.1.5 port=5432 dbname=mydb

[pgbouncer]
pool_mode = transaction
max_client_conn = 1000
default_pool_size = 20
reserve_pool_size = 5
ignore_startup_parameters = extra_float_digits, application_name

此配置禁用会话级状态保留，使每个事务独占连接生命周期，与 Go 的 sql.Tx 语义对齐；ignore_startup_parameters 防止 Go 驱动设置的 extra_float_digits 触发连接重置。

连接生命周期对比表

阶段	Go sql.DB 默认行为	配合 transaction 模式安全行为
事务开始	复用空闲连接	分配新连接（由 default_pool_size 保障）
事务提交/回滚	释放连接回 Go 池	连接立即归还 PgBouncer 并清空会话状态
空闲连接	可能被 Go 池长期持有	PgBouncer 在 server_idle_timeout 后主动关闭

graph TD
    A[Go sql.Open] --> B[Acquire conn from sql.DB pool]
    B --> C{Tx.Begin?}
    C -->|Yes| D[Request new conn from PgBouncer]
    C -->|No| E[Use idle conn]
    D --> F[Execute in transaction mode]
    F --> G[Auto-return after COMMIT/ROLLBACK]
    G --> H[Go pool sees clean conn]

4.2 基于sqlmock+testify的连接泄漏单元测试防护网构建

为什么连接泄漏难以在测试中暴露？

数据库连接池资源有限，泄漏常表现为偶发性超时或 too many connections 错误，仅靠功能测试无法稳定复现。

核心防护策略

• 使用 sqlmock 拦截 SQL 执行并验证连接生命周期
• 结合 testify/assert 断言连接关闭行为
• 在 defer db.Close() 前注入 mock.ExpectClose() 验证

关键代码示例

func TestDBQueryWithLeakDetection(t *testing.T) {
    db, mock, err := sqlmock.New()
    assert.NoError(t, err)
    defer db.Close() // 必须显式调用

    mock.ExpectQuery("SELECT").WillReturnRows(
        sqlmock.NewRows([]string{"id"}).AddRow(1),
    )
    mock.ExpectClose() // 强制要求 Close() 被调用

    _, _ = db.Query("SELECT id FROM users")
    assert.NoError(t, mock.ExpectationsWereMet()) // 若未 Close，此处失败
}

逻辑分析：mock.ExpectClose() 声明“预期 db.Close() 被调用”，ExpectationsWereMet() 检查所有期望是否满足。若业务代码遗漏 defer db.Close()，该断言直接失败，实现泄漏即阻断。

防护效果对比

场景	传统测试	sqlmock+testify 防护网
连接未关闭（泄漏）	无感知	测试立即失败
查询异常后未释放连接	偶发失败	确定性捕获

4.3 Prometheus+Grafana监控看板中连接池健康度5大黄金指标设计

连接池健康度需从资源利用、响应质量与稳定性三个维度建模。以下是核心黄金指标设计：

指标定义与采集逻辑

• pool_active_connections：当前活跃连接数（Prometheus Counter）
• pool_idle_connections：空闲连接数（Gauge，实时反映缓冲能力）
• pool_wait_seconds_total：线程等待连接的累计耗时（直击阻塞瓶颈）
• pool_acquire_failures_total：获取连接失败次数（关键异常信号）
• pool_mean_acquire_time_ms：平均获取连接耗时（毫秒级延迟敏感指标）

Prometheus 查询示例

# 计算连接获取失败率（滑动窗口内）
rate(pool_acquire_failures_total[5m]) 
  / 
rate(pool_acquire_attempts_total[5m])

该表达式通过速率比值消除绝对量干扰，[5m]确保观测窗口覆盖典型业务周期，分母需预先暴露acquire_attempts_total计数器。

指标关联性视图（Mermaid）

graph TD
  A[pool_active_connections] --> B[资源饱和预警]
  C[pool_wait_seconds_total] --> D[线程阻塞分析]
  E[pool_acquire_failures_total] --> F[熔断决策依据]

指标	健康阈值	异常含义
pool_mean_acquire_time_ms		>100ms 表明底层DB或网络延迟恶化
pool_wait_seconds_total	rate	持续增长预示连接泄漏或配置过小

4.4 连接泄漏熔断器（Connection Leak Breaker）中间件的轻量级实现与注入

核心设计思想

以“超时即熔断”为原则，不依赖全局连接池监控，仅在请求生命周期内埋点追踪资源持有时长。

轻量级实现（Go 示例）

func ConnectionLeakBreaker(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
        defer cancel() // 触发时自动清理未释放资源
        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)
    })
}

逻辑分析：context.WithTimeout 在请求上下文中植入截止时间；defer cancel() 确保无论是否异常退出，超时信号均被广播。参数 30*time.Second 可按业务敏感度动态配置，非硬编码。

注入方式对比

方式	侵入性	配置灵活性	适用场景
中间件链式注入	低	高	HTTP 服务入口
拦截器代理封装	中	中	gRPC/SDK 集成

熔断触发流程

graph TD
    A[HTTP 请求进入] --> B{Context 超时？}
    B -->|是| C[Cancel Context]
    B -->|否| D[正常执行 Handler]
    C --> E[触发资源清理钩子]
    E --> F[记录泄漏告警]

第五章：从雪崩到稳态——Go云原生数据库访问范式升级

连接池失控引发的生产事故回溯

2023年Q3，某电商订单服务在大促峰值期间突发5分钟级全链路超时。根因定位显示：database/sql 默认连接池未配置 SetMaxOpenConns(20)，导致瞬时并发请求激增至800+，MySQL服务器连接数打满（max_connections=1000），同时大量goroutine阻塞在connPool.waitCount，触发级联雪崩。事后通过Prometheus采集sql_db_open_connections与sql_db_wait_duration_seconds指标，确认连接等待中位数达4.2s。

基于Context的查询熔断实践

在用户画像服务中，我们为关键查询注入带超时的context：

ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
defer cancel()
rows, err := db.QueryContext(ctx, "SELECT * FROM profiles WHERE uid = ?", uid)
if errors.Is(err, context.DeadlineExceeded) {
    metrics.Inc("db_query_timeout", "profiles")
    return nil, fmt.Errorf("profile query timeout")
}

配合OpenTelemetry追踪，发现3.7%的慢查询集中在profiles表未命中索引的模糊搜索场景，推动DBA添加idx_uid_created_at复合索引后P99响应降至86ms。

连接池参数动态调优机制

采用Consul KV存储连接池配置，支持运行时热更新：

参数	生产值	调优依据	监控阈值
MaxOpenConns	40	AWS RDS t4g.xlarge (4 vCPU)	>95%利用率告警
MaxIdleConns	20	避免空闲连接被RDS自动回收	idle_time > 300s
ConnMaxLifetime	30m	兼容RDS连接复用策略	lifetime

通过定时任务每5分钟拉取Consul配置，调用db.SetMaxOpenConns()实现无损调整。

基于eBPF的连接泄漏检测

在Kubernetes DaemonSet中部署bpftrace脚本，实时捕获未释放的连接：

# trace goroutines holding DB connections longer than 5s
bpftrace -e 'uprobe:/usr/local/go/pkg/linux_amd64/runtime.a:runtime.gopark { 
  @start[tid] = nsecs; 
} uretprobe:/usr/local/go/pkg/linux_amd64/database/sql.a:database/sql.(*DB).Conn { 
  $dur = nsecs - @start[tid]; 
  if ($dur > 5000000000) { 
    printf("leak: %d ns, PID %d\n", $dur, pid); 
  } 
  delete(@start, tid); 
}'

上线首周捕获3处defer rows.Close()遗漏，其中1处位于error分支外层逻辑。

分库分表路由的透明化改造

将ShardingSphere-Proxy替换为Go原生分片SDK，通过sqlparser解析AST提取sharding key：

func parseShardKey(stmt string) (string, error) {
    tree, err := parser.Parse(stmt)
    if where, ok := tree.(*ast.SelectStmt).Where.(*ast.BinaryExpr); ok {
        if where.Op == token.EQL && isShardColumn(where.L) {
            return extractValue(where.R), nil
        }
    }
    return "", ErrNoShardKey
}

结合etcd中维护的shard_map/{tenant_id}配置，实现租户级自动路由，QPS提升2.3倍且跨分片JOIN错误率归零。

混沌工程验证韧性边界

使用Chaos Mesh注入网络延迟故障：

apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: db-latency
spec:
  action: delay
  mode: one
  selector:
    namespaces: ["order-service"]
  network-delay:
    latency: "100ms"
    correlation: "0.5"

验证发现pgx驱动在pgconn.Connect()阶段未设置Dialer.Timeout，导致故障恢复时间长达12s，补丁后收敛至1.8s。

多活架构下的事务一致性保障

在双AZ部署中，通过pglogrepl监听WAL日志构建最终一致性视图，当主库写入后触发INSERT INTO shadow_orders SELECT ...同步至灾备库，利用pg_replication_origin_advance()确保位点精确对齐，实测RPO

指标驱动的容量水位预警

在Grafana中构建复合看板，当sum(rate(sql_db_wait_count[1m])) / sum(rate(sql_db_open_connections[1m])) > 0.3持续5分钟时，自动触发扩容流程——调用AWS SDK修改RDS实例类并重启连接池。