码龙大大头像
数据库主从复制延迟超阈值报警排查:大事务(Large Transactions)引发的阻塞急救封面图

数据库主从复制延迟超阈值报警排查:大事务(Large Transactions)引发的阻塞急救

上周三下午四点二十,运维告警群如同被点燃的鞭炮般炸开了锅:
“核心只读库从库延迟超过 60 秒!”
“从库延迟超过 300 秒!”
“从库延迟突破 1500 秒!”

读写分离中间件依据高可用策略,在判定从库延迟超标后,迅速将全网每秒数千次的读请求全量踢回了主库。主库的 CPU 曲线在两分钟内从 25% 陡增到 92%,商品详情页大面积白屏,客服投诉电话瞬间被打爆。

紧急连入从库执行 SHOW REPLICA STATUS\G,刺眼的数字赫然在目:

  • Seconds_Behind_Master: 1845
  • Replica_SQL_Running_State: Executing event
  • Last_Error: "" (无报错,但在疯狂重放)

主库上业务看似早已提交完毕,为什么从库却像喝了强效胶水一样,被死死卡在某一个 Binlog 位置整整半个小时无法动弹?


凶手现形:一条 SQL 改动 45 万行的灾难

我们通过 mysqlbinlog --base64-output=DECODE-ROWS -v 顺着从库正在读取的 Binlog 偏移量反解日志,一桩由大事务(Large Transaction)引发的血案浮出水面。

为了在双 11 前清理某下架类目的陈旧数据,运营在管理后台点击了一个批量下架按钮,后端直接执行了这样一条看似简单的 SQL:

UPDATE goods_stock 
SET status = 0, stock_locked = 0, update_time = NOW() 
WHERE category_id = 18 AND is_deleted = 0;

这条语句在主库上只执行了约 7 秒就返回成功了,然而在分布式主从复制的物理世界里,它却是一场毁灭性的灾难:

主库 (Master) ──[ 并发写/内存快 ]──> 产生 45 万行 ROW Binlog (约 380MB)
                                                  │ (网络传输传输数分钟)
                                                  ▼
从库 (Replica) ──[ 单 Worker 串行重放 ] <── 接收巨型事务块
       │
       ▼
 ┌────────────────────────────────────────────────────────┐
 │ 必须完整重放这 45 万行,其后的数万个用户小订单全被挂起 │
 └────────────────────────────────────────────────────────┘
  1. ROW 模式下的写放大效应:MySQL 生产环境普遍采用 binlog_format = ROW。一条改动 45 万行的语句,Binlog 里会逐行记录 45 万对 before-image 与 after-image,瞬间生成了超过 380MB 的 Binlog 数据包。
  2. 重放机制的串行锁死:即便开启了基于库(DATABASE)或表(LOGICAL_CLOCK)的多线程并行复制(MTS),对于同一个事务而言,它永远只能被分配给某一个独立的 Worker 线程单枪匹马串行执行。
  3. 主从重放耗时不对称:主库执行时拥有最新的内存 Buffer Pool 热缓存;而从库接收到这 380MB 的事件流后,必须从冷磁盘中重新载入大量数据页,且单线程处理 45 万次行版本变更,直接把同步延迟拉长到半小时以上。

现场急救三板斧:保卫主库与加速排毒

面对不断恶化的从库延迟,第一原则是保住主库存活,切断雪崩传导链条。

第一步:读写分离中间件限流降级

绝不能任由读流量把主库压垮。我们立即在网关与数据库代理层下发指令:

  • 对非核心链路(如历史评价、商家报表)开启降级,直接返回静态缓存或友好提示;
  • 对核心下单读,强制开启主库熔断限流,将主库 CPU 强行从 92% 压回到 65% 安全线。

第二步:从库临时“松绑”加速重放

既然从库只是在苦苦消化这 45 万行数据,且它本身作为从节点不承担权威落盘责任,我们在从库会话中临时关闭双 1 强刷盘策略,给从库磁盘卸掉枷锁:

-- 临时降低从库刷盘安全等级以换取极限吞吐 (现场急救,恢复后再切回)
SET GLOBAL innodb_flush_log_at_trx_commit = 2;
SET GLOBAL sync_binlog = 0;

这一操作让从库的每秒重放速度提升了近 4 倍,不到 6 分钟,积压的巨型 Binlog 终于被彻底吃完,Seconds_Behind_Master 迅速归零,只读流量平稳切回从库。


根治方案:WRITESET 并行复制与微事务切片

消除大事务隐患,不能光靠现场抢救,必须从底层复制参数与业务代码规范上双管齐下。

1. 开启基于 WRITESET 的并行复制

MySQL 传统的并行复制依赖锁或者事务提交组。从 MySQL 8.0 起,推荐开启基于主键/唯一索引哈希的 WRITESET 依赖追踪:

# my.cnf 核心配置
binlog_transaction_dependency_tracking = WRITESET
transaction_write_set_extraction = XXHASH64
binlog_transaction_dependency_history_size = 25000

# 从库启用多线程重放
replica_parallel_type = LOGICAL_CLOCK
replica_parallel_workers = 16
replica_preserve_commit_order = ON

只要两个事务修改的行主键没有冲突,从库的 16 个 Worker 就可以真正实现无拘无束的跨事务并行重放。

2. 业务层微事务分批调度器(Go 1.27.1 实现)

在业务代码层面,下达绝对军规:任何批量变更单次事务更新行数不得超过 500 行。

以下是用 Go 1.27.1 编写的分批幂等切片调度器,利用泛型方法实现了无锁游标分页与自适应间隔休眠,从源头上杜绝大事务:

package migration

import (
	"context"
	"database/sql"
	"fmt"
	"time"
)

// BatchConfig 批处理切片配置
type BatchConfig struct {
	BatchSize   int           // 单批处理行数 (如 500)
	SleepAfter  time.Duration // 每批提交后休眠时间 (给从库复制喘息窗口,如 20ms)
	MaxDuration time.Duration
}

// BatchMigrator 分批事务迁移器
type BatchMigrator struct {
	db  *sql.DB
	cfg BatchConfig
}

func NewBatchMigrator(db *sql.DB, cfg BatchConfig) *BatchMigrator {
	return &BatchMigrator{db: db, cfg: cfg}
}

// ProcessByCursor 使用 Go 1.27.1 泛型方法实现基于主键游标的平滑切片执行
func (m *BatchMigrator) ProcessByCursor[T ~int | ~int64](ctx context.Context, categoryID int, startID T) (int64, error) {
	var totalAffected int64
	currentID := startID

	for {
		select {
		case <-ctx.Done():
			return totalAffected, ctx.Err()
		default:
		}

		// 显式开启微事务,限定 500 行,利用主键索引覆盖
		tx, err := m.db.BeginTx(ctx, nil)
		if err != nil {
			return totalAffected, err
		}

		query := `
			UPDATE goods_stock 
			SET status = 0, stock_locked = 0, update_time = NOW() 
			WHERE id >= ? AND category_id = ? AND is_deleted = 0 
			ORDER BY id ASC LIMIT ?`

		res, err := tx.ExecContext(ctx, query, currentID, categoryID, m.cfg.BatchSize)
		if err != nil {
			_ = tx.Rollback()
			return totalAffected, fmt.Errorf("batch exec failed at id %v: %w", currentID, err)
		}

		affected, _ := res.RowsAffected()
		if err := tx.Commit(); err != nil {
			return totalAffected, err
		}

		totalAffected += affected

		// 如果影响行数小于批次上限,说明处理完毕
		if affected < int64(m.cfg.BatchSize) {
			break
		}

		// 寻找下一批次的起始 ID
		var nextID T
		findNextQuery := `SELECT id FROM goods_stock WHERE id >= ? AND category_id = ? AND is_deleted = 0 ORDER BY id ASC LIMIT 1 OFFSET ?`
		err = m.db.QueryRowContext(ctx, findNextQuery, currentID, categoryID, m.cfg.BatchSize).Scan(&nextID)
		if err == sql.ErrNoRows {
			break
		} else if err != nil {
			return totalAffected, err
		}
		currentID = nextID

		// 强制让出时间片,让 Binlog 均匀平缓地飞往从库
		time.Sleep(m.cfg.SleepAfter)
	}

	return totalAffected, nil
}

总结:大促数据库保障的底线思维

大促前夕的系统脆弱性往往潜伏在看似普通的管理后台操作中:

  1. 禁止一切无界全量 UPDATE/DELETE:哪怕只在白天改动一万行,也必须强制通过游标拆解成微事务;
  2. 从库复制必须上 WRITESET:告别陈旧的单线程模式,释放多核 CPU 的并行重放潜力;
  3. 监控告警建立多级梯队:在延迟达到 15 秒时就应触发二级告警并介入追踪,决不能等到延迟突破上千秒引发主库雪崩时才慌忙救火。

给生产数据库留出敬畏之心,把大事务化整为零,业务的底座才能在大促风浪面前固若金汤。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/baronbool/article/details/168249993

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--