↓ 跳过正文
  1. 文章/

从 JVM Socket Read 到 MySQL 行锁:一次库存回写阻塞的完整排障实战

·3853 字·8 分钟·
作者
hengyuss
这里是我的个人博客。
目录

一次库存回写任务长时间没有完成,Java 线程栈却显示线程处于 RUNNABLE,并停留在 Socket Read。问题究竟出在应用、网络、数据库连接池, 还是 MySQL?

本文通过一个本地故障实验,记录从 JVM 线程快照到 MySQL 行锁的完整排查过程, 并说明每项证据能证明什么、不能证明什么。

一、故障背景
#

项目采用 Redis 预扣库存、MySQL 异步回写的方式处理活动 SKU 库存:

1业务请求
2  → Redis 原子扣减库存
3  → 将 activityId_sku 写入 dirty set
4  → 定时任务认领 dirty SKU
5  → 读取 Redis 最新库存
6  → 更新 MySQL
7  → Ack 清理 processing 状态

库存回写任务每秒执行一次。正常情况下,MySQL 中的剩余库存会很快追平 Redis。这次实验人为锁住目标库存记录,使定时任务的 UPDATE 无法获得 行锁。

本文的故障注入只应在本地或专用测试环境执行,禁止直接在生产库操作。

二、制造一个可控的行锁等待
#

1. 会话 A:锁住目标库存记录
#

打开第一个 MySQL 会话,开启事务并锁定一条明确的 SKU 记录:

1START TRANSACTION;
2
3SELECT activity_id, sku, stock_count_surplus
4FROM raffle_activity_sku
5WHERE activity_id = 100301
6  AND sku = 9011
7FOR UPDATE;

暂时不要执行 COMMIT 或 ROLLBACK。

实验时不要使用没有过滤条件的 SELECT * FROM raffle_activity_sku FOR UPDATE, 它可能锁住大量记录。

2. 触发库存回写
#

通过正常业务流程扣减一次 SKU 库存,随后库存定时任务会执行类似 SQL:

1UPDATE raffle_activity_sku
2SET stock_count_surplus = CASE
3    WHEN activity_id = 100301 AND sku = 9011
4    THEN LEAST(stock_count_surplus, 99891)
5    ELSE stock_count_surplus
6END,
7update_time = NOW()
8WHERE (activity_id, sku) IN ((100301, 9011));

由于会话 A 尚未提交事务,库存回写会一直等待同一条记录的锁。此时可以观察到:

  • Redis 库存已经扣减;
  • MySQL 库存仍是旧值;
  • processing 状态迟迟没有被 Ack;
  • 库存回写任务没有打印完成日志。

三、从 JVM 侧确定线程在等待什么
#

1. 找到 Java 进程
#

1jps -l

示例输出:

1331941  com.intellij.idea.Main
23714266 jdk.jcmd/sun.tools.jps.Jps
33370762 com.hengyuss.Application

目标应用 PID 为 3370762。

2. 连续抓取两份线程快照
#

一份线程快照只能说明采样瞬间线程正在做什么。为了区分瞬时执行和持续阻塞, 应该间隔几秒连续抓取:

1jstack -l 3370762 > /tmp/big-market-1.txt
2sleep 5
3jstack -l 3370762 > /tmp/big-market-2.txt

项目使用 Spring 定时任务,因此先查找 scheduling- 线程:

1rg -n -A 140 '"scheduling-' /tmp/big-market-1.txt
2rg -n -A 140 '"scheduling-' /tmp/big-market-2.txt

关键线程栈如下:

 1"scheduling-1" #120 cpu=726.97ms elapsed=1938.00s runnable
 2   java.lang.Thread.State: RUNNABLE
 3    at sun.nio.ch.Net.poll(Native Method)
 4    at sun.nio.ch.NioSocketImpl.park(NioSocketImpl.java:186)
 5    at sun.nio.ch.NioSocketImpl.implRead(NioSocketImpl.java:319)
 6    at java.net.Socket$SocketInputStream.read(Socket.java:966)
 7    at sun.security.ssl.SSLSocketImpl$AppInputStream.read(SSLSocketImpl.java:1069)
 8    at com.mysql.cj.protocol.FullReadInputStream.readFully(FullReadInputStream.java:64)
 9    at com.mysql.cj.protocol.a.NativeProtocol.readMessage(NativeProtocol.java:538)
10    at com.mysql.cj.protocol.a.NativeProtocol.sendCommand(NativeProtocol.java:647)
11    at com.mysql.cj.jdbc.ClientPreparedStatement.executeInternal(ClientPreparedStatement.java:930)
12    at com.zaxxer.hikari.pool.HikariProxyPreparedStatement.execute(...)
13    at org.apache.ibatis.executor.statement.PreparedStatementHandler.update(...)

完整线程栈还应继续追踪到项目中的库存定时任务、领域服务、仓储和 Mapper。

3. 如何阅读这段线程栈
#

从下往上可以还原调用链:

1Spring 库存定时任务
2  → MyBatis 执行 UPDATE
3  → Hikari PreparedStatement
4  → MySQL JDBC Driver
5  → Socket Read 等待 MySQL 返回
  • PreparedStatementHandler.update:MyBatis 正在执行更新;
  • HikariProxyPreparedStatement.execute:线程已经取得数据库连接,不是卡在连接池借连接;
  • com.mysql.cj.*:这个 Socket 属于 MySQL JDBC;
  • SocketInputStream.read、Net.poll:SQL 已发出,客户端正在等待 MySQL 响应。

Socket Read 只能证明客户端在等 MySQL,不能单独证明是行锁。慢 SQL、 磁盘 I/O、数据库负载和网络异常也可能产生相似线程栈。

4. 为什么 RUNNABLE 仍可能是阻塞
#

JVM 的线程状态比较粗。线程在 native Socket 的 poll 中等待数据时,也可能 显示为 RUNNABLE。

判断它是否真的在计算,需要对比多份快照。实验中两次快照的线程 ID 和调用位置 相同,而二十多秒内 CPU 时间只增加约 2 毫秒,说明线程没有持续消耗 CPU, 而是在等待 I/O。

线程栈中的:

1- locked <...> (a com.mysql.cj.jdbc.ConnectionImpl)

表示线程持有 Java 层的 ConnectionImpl 对象监视器,不是 MySQL 行锁。 MySQL 行锁必须从数据库侧取证。

四、从 MySQL 侧定位阻塞原因
#

1. 使用 Processlist 找到长期执行的 SQL
#

在第二个 MySQL 会话执行:

1SHOW FULL PROCESSLIST;

省略无关连接后,关键结果如下:

1Id    Command  Time  State     Info
22673  Query      37  updating  UPDATE raffle_activity_sku ...

库存 UPDATE 已执行 37 秒仍未完成,说明 JDBC 的长时间等待确实对应数据库 中的这条 SQL。

执行 SHOW FULL PROCESSLIST 的连接也会出现在结果里,它的 Info 是 show full processlist。这是正常的观察者效应,不意味着诊断 SQL 有问题。

Processlist 只能说明 SQL 长时间没有结束,还不能区分慢 SQL 和锁等待。

2. 查询锁等待关系
#

MySQL 8 可以查询:

 1SELECT
 2    waiting_pid,
 3    waiting_query,
 4    wait_age,
 5    locked_table,
 6    locked_index,
 7    waiting_lock_mode,
 8    blocking_pid,
 9    blocking_query
10FROM sys.innodb_lock_waits\G

实验结果:

1waiting_pid:       2718
2waiting_query:     UPDATE raffle_activity_sku ...
3wait_age:          00:00:30
4locked_table:      `big_market`.`raffle_activity_sku`
5locked_index:      uq_sku
6waiting_lock_mode: X,REC_NOT_GAP
7blocking_pid:      2669
8blocking_query:    SELECT ... FROM sys.innodb_lock_waits

这段结果可以翻译为:

连接 2718 的库存 UPDATE 已等待 30 秒。它希望获得 uq_sku 索引记录的 排他锁,但该锁被连接 2669 持有。

其中:

  • X 表示排他锁;
  • REC_NOT_GAP 表示锁定具体索引记录,不是索引间隙;
  • waiting_pid 是受害者;
  • blocking_pid 才是阻塞者。

不要只终止 waiting PID。只处理等待者,应用稍后重试时仍会遇到同一个阻塞事务。

3. 为什么 blocking query 显示诊断 SQL
#

连接 2669 正是会话 A。它先执行 SELECT ... FOR UPDATE 获得行锁,随后又在 同一个未提交事务中执行了诊断查询。

blocking_query 展示的是采样瞬间连接正在执行的语句,不一定是最初获得锁 的语句。锁属于事务,不属于某一条当前 SQL。只要事务没有提交,之前获得的行锁 就不会释放。

如果诊断查询执行完毕,从另一个会话观察时,2669 可能显示为:

1Command: Sleep
2Info:    NULL

它仍然可以持有行锁,因为 Sleep 只表示连接当前没有执行 SQL,不表示事务 已经结束。

4. 查询事务状态
#

继续查询 InnoDB 事务:

 1SELECT
 2    trx_id,
 3    trx_state,
 4    trx_started,
 5    trx_wait_started,
 6    trx_mysql_thread_id,
 7    trx_rows_locked,
 8    trx_query
 9FROM information_schema.innodb_trx
10ORDER BY trx_started\G

阻塞事务:

1trx_id:              3546742
2trx_state:           RUNNING
3trx_started:         2026-11-16 15:00:50
4trx_mysql_thread_id: 2669
5trx_rows_locked:     2

等待事务:

1trx_id:              3546791
2trx_state:           LOCK WAIT
3trx_started:         2026-11-16 15:41:15
4trx_wait_started:    2026-11-16 15:41:15
5trx_mysql_thread_id: 2721
6trx_query:            UPDATE raffle_activity_sku ...

阻塞事务已经存活约 40 分钟。等待事务一开始执行就进入 LOCK WAIT,说明库存 UPDATE 访问目标记录时立即遇到锁冲突。

trx_rows_locked 是 InnoDB 内部的近似统计,可能同时涉及二级索引记录和聚簇 索引记录,不宜直接理解为锁住同样数量的业务行。

5. 为什么 waiting PID 前后不同
#

Processlist、锁等待视图和事务视图是在不同时间采集的,因此等待连接可能从 2673 变为 2718、2721。

一种可能的解释是:库存 SQL 达到 innodb_lock_wait_timeout 后失败,定时任务 捕获异常并重试,下一次从 Hikari 连接池取得了不同连接。这个判断需要使用应用 中的 Lock wait timeout exceeded 日志验证,不能仅凭 PID 变化直接认定。

1rg -n 'Lock wait timeout|更新活动sku库存失败|批量同步活动 SKU' data/log/log_info.log

五、形成完整证据链
#

 1业务现象
 2Redis 库存已经扣减,但 MySQL 长时间没有更新
 3        ↓
 4JVM 线程快照
 5scheduling-1 持续停在 MySQL JDBC Socket Read
 6        ↓
 7MySQL Processlist
 8库存 UPDATE 长时间处于 updating
 9        ↓
10InnoDB Lock Waits
11UPDATE 等待 uq_sku 上的排他记录锁
12        ↓
13InnoDB Transaction
14连接 2669 的长事务未提交并持有锁

最终根因是:

一个长期未提交的事务通过 SELECT ... FOR UPDATE 持有库存记录锁,导致 库存回写 UPDATE 进入锁等待。Java 定时线程已经取得数据库连接并发出 SQL, 只能阻塞在 Socket Read 中等待 MySQL 返回。

六、恢复现场并验证
#

在会话 A 执行:

1COMMIT;

也可以根据实验目的执行 ROLLBACK。事务结束后,MySQL 会释放相关记录锁。

再次查询:

1SELECT * FROM sys.innodb_lock_waits;

预期结果为空。随后继续验证:

  1. MySQL 库存是否更新为 Redis 中的最新值;
  2. Redis processing owner 是否被 Ack;
  3. Redis processing deadline 是否被清理;
  4. 库存定时任务是否打印完成日志;
  5. 其他定时任务是否恢复执行。

只有“阻塞消失、数据追平、任务恢复”同时满足,才能认为恢复验证完成。

七、问题为什么会被放大
#

行锁是直接原因,项目中的两个设计会进一步放大影响。

1. 多个定时任务共享单线程 Scheduler
#

项目没有单独配置 Spring 调度线程池时,默认只有一个 scheduling-1。库存 回写一旦长时间等待数据库,其他 @Scheduled 任务也无法按时运行。

这不会直接阻塞已经进入 RabbitMQ 的消息消费,但可能拖延同样依赖 Scheduler 的消息补偿发送任务。

最小隔离配置可以从下面开始:

1spring:
2  task:
3    scheduling:
4      pool:
5        size: 4
6      thread-name-prefix: scheduling-

增加线程数只能隔离故障影响,不能解决未提交长事务这个根因。更重要的任务还可以 使用独立调度器或独立进程隔离。

2. Redis 租约可能短于数据库等待时间
#

库存 processing 租约为 30 秒,而 MySQL 默认锁等待时间通常更长。如果存在多个 应用实例,可能出现:

1实例 A Claim SKU,SQL 开始等待行锁
2  → 30 秒后租约过期
3  → 实例 B Recover 并重新 Claim
4  → A 尚未结束,B 又开始执行同一库存 SQL

数据库绝对库存同步和 token 校验可以保护最终结果,但重复执行仍会额外占用数据库 连接。设计时至少应满足:

1数据库操作超时 < processing 租约

长任务还应考虑租约续期或 fencing token,避免旧执行者在租约失效后继续提交结果。

八、修复方向
#

1. 控制事务边界
#

  • 事务只包含必须原子完成的数据库操作;
  • 不在事务中执行远程调用、长时间计算或人为等待;
  • 所有异常路径都必须提交或回滚;
  • 对手工 JDBC 操作使用 try/finally 关闭资源;
  • 监控长事务和 idle in transaction。

2. 配置超时,避免长期等待
#

  • 为业务事务设置合理超时;
  • 为关键 SQL 设置查询或锁等待超时;
  • 保证数据库超时、Redis 租约和任务重试间隔相互匹配;
  • 不要只依赖数据库的全局默认值。

3. 隔离定时任务
#

  • 配置多线程 Scheduler,避免单任务阻塞所有定时任务;
  • 为库存回写、消息补偿等重要任务使用独立执行资源;
  • 使用有界队列和有限并发,避免故障时无限堆积;
  • 多实例部署时增加任务认领、租约和幂等控制。

4. 增加可观测性
#

建议至少监控:

  • dirty SKU 数量;
  • 最老 dirty SKU 的年龄;
  • processing 数量和超时恢复次数;
  • 库存同步耗时与失败次数;
  • MySQL 行锁等待数和长事务数;
  • Hikari active、idle、pending 和 timeout;
  • 每个定时任务的实际触发间隔与执行耗时。

只监控 dirty set 的成员数量还不够。它是 Set,同一个热点 SKU 扣减很多次也只有 一个成员,因此还需要监控 Redis 与 MySQL 的库存差值和脏状态持续时间。

九、生产环境排查注意事项
#

本地实验可以主动制造锁,生产环境不能照搬。真实事故中应遵循:

  1. 先评估影响范围并保留现场证据;
  2. 连续抓取多份线程快照,而不是只看一份;
  3. 同时检查 Processlist、事务和锁等待关系;
  4. 确认 blocking PID 的业务归属和回滚代价;
  5. 不要看到等待连接就直接执行 KILL;
  6. 止血后继续修复事务边界、超时和资源隔离问题;
  7. 将排查命令、指标和处理流程沉淀为 Runbook。

十、总结
#

这次排查最重要的不是记住某一条 SQL,而是掌握跨层取证的方法:

1线程名确定工作负载
2  → JVM 栈确定正在等待 MySQL
3  → Processlist 找到长期执行的 SQL
4  → innodb_lock_waits 确认等待者和阻塞者
5  → innodb_trx 确认长事务
6  → COMMIT/ROLLBACK 后验证系统恢复

最后记住两个容易误判的结论:

Socket Read 说明客户端正在等待数据库响应,不代表网络一定有问题。

Sleep 说明连接当前没有执行 SQL,不代表事务已经结束,也不代表它没有持锁。