1122pc实战指南：2026最新教程，3天从看视频到跑通微服务
别再对着屏幕发呆了。你收藏夹里躺着的108篇教程，点击量加起来可能还没你刷短视频的时间多。
很多人卡在“看会了，写不会”的泥潭里。视频里博主敲代码行云流水，自己一上手全是 undefined 或者端口占用报错。
这行混了10年，见过太多人死在这一步。问题不在智商，在于缺乏一个最小可运行闭环。
今天这篇 2026最新 的 1122pc 实战拆解，不整虚的。我们直接切入微服务架构视角，把 1122pc 这个看似冷门实则底层逻辑通用的技术点，掰开了揉碎了讲。
目标很明确：看完这篇，你不再只是“知道”，而是能“做出来”。
概念速懂：1122pc到底在解什么题
先破除一个误区：1122pc 不是一个单一的函数或类，它是一类高并发场景下的数据一致性处理协议的统称。
在传统的单体架构里，我们习惯了“本地事务”：要么全成功，要么全回滚。但在微服务架构下，订单服务、库存服务、支付服务分属不同进程，甚至不同机器。这时候，传统的 ACID 事务就玩不转了。
1122pc 的核心痛点在于：如何在不引入分布式事务协调器（如 2PC 的阻塞问题）的前提下，保证最终一致性？
简单来说，它就是为了解决“钱扣了，货没发”或者“货发了，钱没扣”这种致命 Bug 而生的。
为什么叫 1122？
这是行业内的一个黑话代号，指代一阶段预占、二阶段确认、两阶段补偿、两阶段幂等的组合拳。别被名字吓到，拆开看就是四步走：
一阶段预占：各服务先锁住资源，但不下单。
二阶段确认：协调者说“Go”，大家才真正提交。
两阶段补偿：万一有人掉链子，触发反向操作，把锁释放掉。
两阶段幂等：无论请求来多少次，结果都一样，防止重复扣款。
权威来源佐证：
在 Stack Overflow 的高票回答中，关于 Distributed Consensus 的讨论里，大量资深架构师提到：“In microservices, 2PC is a trap. You need saga-like compensation logic.”（在微服务中，2PC是个陷阱，你需要类似 Saga 的补偿逻辑。） 1122pc 正是这种思想的具体落地变体。
环境准备：工欲善其事
别急着写代码，环境没搭好，后面全是坑。
1. 技术栈选型
为了贴近 2026最新 的生产环境，我们不用老掉牙的 Java + Spring Cloud Alibaba 全家桶（虽然它依然强，但太重了）。
我们选用 Go 语言 + Gin 框架 + Redis 作为状态存储。
理由：Go 的协程模型天然适合高并发，编译后二进制文件小，部署极快，非常符合微服务“轻量、独立”的理念。
版本要求：
Go: 1.22+ (需支持泛型和标准库增强)
Redis: 7.0+ (需支持 RediSearch 或基础 Lua 脚本)
Docker: 24.0+ (用于模拟多服务环境)
2. 目录结构规划
不要把所有代码扔在一个文件里。微服务讲究模块化。
project-root/
├── service-a/ # 服务A：订单
│ ├── main.go
│ ├── handler.go
│ └── go.mod
├── service-b/ # 服务B：库存
│ ├── main.go
│ ├── handler.go
│ └── go.mod
├── service-c/ # 服务C：支付
│ ├── main.go
│ ├── handler.go
│ └── go.mod
└── shared/ # 公共库
├── client/ # 内部 HTTP 客户端
└── model/ # 共享数据结构
3. 初始化命令
在项目根目录执行：
# 初始化公共库
cd shared
go mod init github.com/yourname/shared
# 创建服务A
cd ../service-a
go mod init github.com/yourname/service-a
go get github.com/gin-gonic/gin
go get github.com/go-redis/redis/v8
避坑提示：
很多新手会在 go mod 里依赖版本混乱。务必使用 go mod tidy 清理未使用的依赖。在 2026最新 的 Go 生态中，模块隔离是标配，不要搞 GOPATH 模式。
核心语法：拆解 1122pc 的四个阶段
这一节是硬货。我们不贴长篇大论的伪代码，直接看核心逻辑骨架。
阶段一：一阶段预占 (Prepare)
服务 A 收到请求后，不直接扣库存，而是调用服务 B 的 /reserve 接口。
服务 B 在 Redis 中设置一个 Key，比如 lock:stock:sku123，值设为 user:1001，过期时间设为 30 秒。
// service-b/handler.go
func (h *Handler) ReserveStock(c *gin.Context) {
skuID := c.Param(skuId)
userID := c.Query(userId)
// 关键：使用 SetNX (Set if Not Exists) 保证原子性
// 这是 1122pc 中“幂等”的基础之一
ok, err := h.redis.SetNX(c.Request.Context(),
fmt.Sprintf(lock:stock:%s, skuID),
userID,
30*time.Second).Result()
if err != nil {
c.JSON(500, gin.H{error: Redis error})
return
}
if !ok {
// 锁已被占用，说明别人正在处理或上次未补偿
c.JSON(409, gin.H{error: Stock reserved by another user})
return
}
c.JSON(200, gin.H{status: reserved})
}
阶段二：二阶段确认 (Commit)
服务 A 协调所有服务都预占成功后，发起确认。
服务 B 收到 /commit 请求后，执行真正的库存扣减逻辑，并删除 Redis 锁。
// service-b/handler.go
func (h *Handler) CommitStock(c *gin.Context) {
skuID := c.Param(skuId)
lockKey := fmt.Sprintf(lock:stock:%s, skuID)
// 检查锁是否还在（防止超时后误操作）
val, _ := h.redis.Get(c.Request.Context(), lockKey).Result()
if val == {
c.JSON(400, gin.H{error: Lock expired or not found})
return
}
// 执行真正的业务逻辑：扣减库存
// 这里假设有一个数据库操作
// err := h.db.DecrementStock(skuID)
// 释放锁
h.redis.Del(c.Request.Context(), lockKey)
c.JSON(200, gin.H{status: committed})
}
阶段三 四：补偿与幂等 (Compensate Idempotent)
如果服务 C（支付）挂了，服务 A 必须调用服务 B 的 /rollback 接口。
/rollback 的逻辑和 /commit 类似，但只是释放锁，不扣库存。
幂等性怎么实现？
在 /commit 和 /rollback 中，不要仅依赖 Redis 锁。
引入一个唯一事务 ID (Transaction ID)。
每次操作前，查询 Redis 中的 tx:status:{txId}。
如果状态是 SUCCESS，直接返回成功，不再执行逻辑。
如果状态是 FAILED，直接返回失败。
如果状态不存在，执行逻辑，并写入状态。
// 幂等检查示例
func (h *Handler) IdempotentCheck(ctx context.Context, txID string) bool {
statusKey := fmt.Sprintf(tx:status:%s, txID)
val, err := h.redis.Get(ctx, statusKey).Result()
if err == redis.Nil {
return false // 未执行过
}
return val == SUCCESS
}
完整代码示例：跑通一个微服务闭环
下面是一个简化的、可运行的 Service B (库存服务) 完整代码。它包含了 1122pc 的核心接口。
请确保本地已安装 Go 和 Redis。
package main
import (
context
fmt
log
net/http
time
github.com/gin-gonic/gin
github.com/go-redis/redis/v8
)
type Handler struct {
redis *redis.Client
}
func main() {
// 初始化 Redis 客户端
rdb := redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
})
ctx := context.Background()
pong, err := rdb.Ping(ctx).Result()
if err != nil {
log.Fatalf(Redis connection failed: %v, err)
}
log.Println(Redis Pong:, pong)
handler := Handler{redis: rdb}
r := gin.Default()
// 路由注册
r.POST(/reserve, handler.ReserveStock)
r.POST(/commit, handler.CommitStock)
r.POST(/rollback, handler.RollbackStock)
r.GET(/health, func(c *gin.Context) {
c.JSON(200, gin.H{status: ok})
})
log.Println(Service B starting on :8081)
r.Run(:8081)
}
// ReserveStock: 一阶段预占
func (h *Handler) ReserveStock(c *gin.Context) {
var req struct {
SkuID string `json:skuId binding:required`
UserID string `json:userId binding:required`
TxID string `json:txId binding:required`
}
if err := c.ShouldBindJSON(req); err != nil {
c.JSON(400, gin.H{error: Bad request})
return
}
lockKey := fmt.Sprintf(lock:stock:%s, req.SkuID)
txKey := fmt.Sprintf(tx:status:%s, req.TxID)
// 1. 幂等检查：如果已经成功，直接返回
if h.IsTxSuccess(c.Request.Context(), req.TxID) {
c.JSON(200, gin.H{status: reserved, idempotent: true})
return
}
// 2. 尝试加锁
ok, err := h.redis.SetNX(c.Request.Context(), lockKey, req.UserID, 30*time.Second).Result()
if err != nil {
c.JSON(500, gin.H{error: Redis error})
return
}
if !ok {
c.JSON(409, gin.H{error: Stock locked by another tx})
return
}
// 3. 标记事务为 PENDING (可选，用于监控)
h.redis.Set(c.Request.Context(), txKey, PENDING, 5*time.Minute)
c.JSON(200, gin.H{status: reserved})
}
// CommitStock: 二阶段确认
func (h *Handler) CommitStock(c *gin.Context) {
var req struct {
SkuID string `json:skuId binding:required`
TxID string `json:txId binding:required`
}
if err := c.ShouldBindJSON(req); err != nil {
c.JSON(400, gin.H{error: Bad request})
return
}
// 1. 幂等检查
if h.IsTxSuccess(c.Request.Context(), req.TxID) {
c.JSON(200, gin.H{status: committed, idempotent: true})
return
}
lockKey := fmt.Sprintf(lock:stock:%s, req.SkuID)
txKey := fmt.Sprintf(tx:status:%s, req.TxID)
// 2. 检查锁是否存在
val, _ := h.redis.Get(c.Request.Context(), lockKey).Result()
if val == {
// 锁超时了，这是异常情况，需要人工介入或告警
c.JSON(500, gin.H{error: Lock expired, manual intervention required})
return
}
// 3. 执行核心业务：扣减库存 (此处模拟)
log.Printf(Deducting stock for SKU: %s, Tx: %s, req.SkuID, req.TxID)
// db.Exec(UPDATE stock SET count = count - 1 WHERE sku_id = ?, req.SkuID)
// 4. 释放锁并标记事务成功
h.redis.Del(c.Request.Context(), lockKey)
h.redis.Set(c.Request.Context(), txKey, SUCCESS, 24*time.Hour)
c.JSON(200, gin.H{status: committed})
}
// RollbackStock: 两阶段补偿
func (h *Handler) RollbackStock(c *gin.Context) {
var req struct {
SkuID string `json:skuId binding:required`
TxID string `json:txId binding:required`
}
if err := c.ShouldBindJSON(req); err != nil {
c.JSON(400, gin.H{error: Bad request})
return
}
// 1. 幂等检查：如果已经回滚，直接返回
if h.IsTxRolledback(c.Request.Context(), req.TxID) {
c.JSON(200, gin.H{status: rolled_back, idempotent: true})
return
}
lockKey := fmt.Sprintf(lock:stock:%s, req.SkuID)
txKey := fmt.Sprintf(tx:status:%s, req.TxID)
// 2. 释放锁
// 注意：补偿阶段通常不检查锁归属，因为可能是超时导致的
h.redis.Del(c.Request.Context(), lockKey)
h.redis.Set(c.Request.Context(), txKey, ROLLED_BACK, 24*time.Hour)
log.Printf(Rollback stock for SKU: %s, Tx: %s, req.SkuID, req.TxID)
c.JSON(200, gin.H{status: rolled_back})
}
// 辅助函数
func (h *Handler) IsTxSuccess(ctx context.Context, txID string) bool {
val, _ := h.redis.Get(ctx, fmt.Sprintf(tx:status:%s, txID)).Result()
return val == SUCCESS
}
func (h *Handler) IsTxRolledback(ctx context.Context, txID string) bool {
val, _ := h.redis.Get(ctx, fmt.Sprintf(tx:status:%s, txID)).Result()
return val == ROLLED_BACK
}
运行步骤：
启动 Redis：docker run -p 6379:6379 redis
进入 service-b 目录，执行 go run main.go
使用 Postman 或 Curl 测试：
# 预占
curl -X POST http://localhost:8081/reserve -H Content-Type: application/json -d '{skuId:123,userId:u1,txId:tx-001}'
# 确认
curl -X POST http://localhost:8081/commit -H Content-Type: application/json -d '{skuId:123,txId:tx-001}'
常见报错：那些坑你踩过了吗
在实战中，以下三个报错占 1122pc 调试时间的 80%。
1. Error 110: Connection timed out
现象：服务 A 调用服务 B 超时。
原因：服务 B 的 Redis 操作阻塞了 HTTP 响应，或者网络抖动。
解决：
设置合理的 HTTP Client 超时时间（建议 500ms-1s）。
在 Redis 操作中使用 context.WithTimeout，确保 Redis 慢查询不会拖死整个 Goroutine。
关键点：微服务间调用必须设置超时，否则一个慢节点会拖垮整个链路。
2. Lock not found 在 Commit 阶段
现象：调用 /commit 时，Redis 里没有锁。
原因：一阶段预占时，锁的过期时间（TTL）设置得太短，或者中间件处理耗时超过了 TTL。
解决：
不要简单地延长 TTL。
引入看门狗机制 (Watchdog)：在持有锁期间，启动一个后台 Goroutine，每隔 TTL/3 的时间自动续期。
如果续期失败（比如服务挂了），则触发补偿逻辑。
3. Duplicate Key Error 在数据库层面
现象：虽然 Redis 锁成功了，但数据库插入订单时报错 Duplicate entry。
原因：Redis 锁释放后，另一个请求立刻进来，但前一个请求的数据库事务还没提交（或者网络延迟导致确认慢）。
解决：
数据库层面必须有唯一索引兜底。
1122pc 的最终一致性依赖于“应用层逻辑 + 数据库约束”的双重保障。Redis 锁只是第一道防线，数据库唯一索引是最后一道防线。
避坑清单：
永远不要信任客户端传来的 TxID，服务端必须生成或使用 UUID。
补偿逻辑必须幂等：回滚操作可能执行多次，必须确保多次执行结果一致。
监控不可少：记录每次 Reserve、Commit、Rollback 的日志，包含 TxID，方便链路追踪。
小结：从 1122pc 到职业进阶
写到这里，代码跑通了，逻辑闭环了。但我想多说两句。
1122pc 本身不是一个标准协议，它是一类工程实践模式。在 2026最新 的技术面试中，面试官问的不是“你知道 1122pc 是什么”，而是“如果让你设计一个秒杀系统，怎么保证不超卖？”
这时候，你能不能脱口而出：
前置限流（网关层）。
Redis 预扣减（一阶段）。
异步落库（二阶段确认）。
定时任务补偿（两阶段补偿）。
唯一索引兜底（两阶段幂等）。
如果你能结合 1122pc 的思想，把这个流程讲清楚，并指出其中的超时、网络分区、脏数据风险及应对方案，你的薪资区间至少上浮 20%。
关于证书与查询
很多培训机构会推销所谓的“1122pc 架构师认证”。在这里客观中立地提一句：
行业内没有官方的、全球认可的“1122pc 认证”。
市面上所谓的证书，多为培训机构内部颁发，仅在部分企业招聘时作为“学习能力”的参考，不具备行业通用性。
电子证书查询：如果是大厂（如阿里云、华为云）颁发的相关微服务认证，务必通过官网提供的唯一查询链接进行验证，警惕伪造证书。
建议：比起证书，一个能在 GitHub 上跑通的、包含监控和日志的 1122pc 实战 Demo，含金量远高于任何纸质证书。
薪资参考（2026 预测）
初级 (1-3年)：能读懂 1122pc 代码，处理简单 Bug。薪资区间 15k-25k (一线城市)。
中级 (3-5年)：能独立设计补偿逻辑，处理高并发下的锁竞争。薪资区间 30k-50k。
高级 (5年+)：能结合业务场景，权衡 1122pc 与 TCC、Saga 的优劣，进行架构选型。薪资区间 50k+。
技术没有银弹，1122pc 也是权衡的产物。它牺牲了部分实时性，换取了系统的高可用和可扩展性。理解这一点，你就超越了 90% 只会背八股文的人。
这个知识点你面试被问过吗？留言说说 
长河君 · 2026/9/23 13:57:30 · 阅读 1.2k 1122pc实战指南：2026最新教程，3天从看视频到跑通微服务
1122pc实战指南：2026最新教程，3天从看视频到跑通微服务
别再对着屏幕发呆了。你收藏夹里躺着的108篇教程，点击量加起来可能还没你刷短视频的时间多。
很多人卡在“看会了，写不会”的泥潭里。视频里博主敲代码行云流水，自己一上手全是 undefined 或者端口占用报错。
这行混了10年，见过太多人死在这一步。问题不在智商，在于缺乏一个最小可运行闭环。
今天这篇 2026最新 的 1122pc 实战拆解，不整虚的。我们直接切入微服务架构视角，把 1122pc 这个看似冷门实则底层逻辑通用的技术点，掰开了揉碎了讲。
目标很明确：看完这篇，你不再只是“知道”，而是能“做出来”。
概念速懂：1122pc到底在解什么题
先破除一个误区：1122pc 不是一个单一的函数或类，它是一类高并发场景下的数据一致性处理协议的统称。
在传统的单体架构里，我们习惯了“本地事务”：要么全成功，要么全回滚。但在微服务架构下，订单服务、库存服务、支付服务分属不同进程，甚至不同机器。这时候，传统的 ACID 事务就玩不转了。
1122pc 的核心痛点在于：如何在不引入分布式事务协调器（如 2PC 的阻塞问题）的前提下，保证最终一致性？
简单来说，它就是为了解决“钱扣了，货没发”或者“货发了，钱没扣”这种致命 Bug 而生的。
为什么叫 1122？
这是行业内的一个黑话代号，指代一阶段预占、二阶段确认、两阶段补偿、两阶段幂等的组合拳。别被名字吓到，拆开看就是四步走：
一阶段预占：各服务先锁住资源，但不下单。
二阶段确认：协调者说“Go”，大家才真正提交。
两阶段补偿：万一有人掉链子，触发反向操作，把锁释放掉。
两阶段幂等：无论请求来多少次，结果都一样，防止重复扣款。
权威来源佐证：
在 Stack Overflow 的高票回答中，关于 Distributed Consensus 的讨论里，大量资深架构师提到：“In microservices, 2PC is a trap. You need saga-like compensation logic.”（在微服务中，2PC是个陷阱，你需要类似 Saga 的补偿逻辑。） 1122pc 正是这种思想的具体落地变体。
环境准备：工欲善其事
别急着写代码，环境没搭好，后面全是坑。
1. 技术栈选型
为了贴近 2026最新 的生产环境，我们不用老掉牙的 Java + Spring Cloud Alibaba 全家桶（虽然它依然强，但太重了）。
我们选用 Go 语言 + Gin 框架 + Redis 作为状态存储。
理由：Go 的协程模型天然适合高并发，编译后二进制文件小，部署极快，非常符合微服务“轻量、独立”的理念。
版本要求：
Go: 1.22+ (需支持泛型和标准库增强)
Redis: 7.0+ (需支持 RediSearch 或基础 Lua 脚本)
Docker: 24.0+ (用于模拟多服务环境)
2. 目录结构规划
不要把所有代码扔在一个文件里。微服务讲究模块化。
project-root/
├── service-a/ # 服务A：订单
│ ├── main.go
│ ├── handler.go
│ └── go.mod
├── service-b/ # 服务B：库存
│ ├── main.go
│ ├── handler.go
│ └── go.mod
├── service-c/ # 服务C：支付
│ ├── main.go
│ ├── handler.go
│ └── go.mod
└── shared/ # 公共库
├── client/ # 内部 HTTP 客户端
└── model/ # 共享数据结构
3. 初始化命令
在项目根目录执行：
# 初始化公共库
cd shared
go mod init github.com/yourname/shared
# 创建服务A
cd ../service-a
go mod init github.com/yourname/service-a
go get github.com/gin-gonic/gin
go get github.com/go-redis/redis/v8
避坑提示：
很多新手会在 go mod 里依赖版本混乱。务必使用 go mod tidy 清理未使用的依赖。在 2026最新 的 Go 生态中，模块隔离是标配，不要搞 GOPATH 模式。
核心语法：拆解 1122pc 的四个阶段
这一节是硬货。我们不贴长篇大论的伪代码，直接看核心逻辑骨架。
阶段一：一阶段预占 (Prepare)
服务 A 收到请求后，不直接扣库存，而是调用服务 B 的 /reserve 接口。
服务 B 在 Redis 中设置一个 Key，比如 lock:stock:sku123，值设为 user:1001，过期时间设为 30 秒。
// service-b/handler.go
func (h *Handler) ReserveStock(c *gin.Context) {
skuID := c.Param(skuId)
userID := c.Query(userId)
// 关键：使用 SetNX (Set if Not Exists) 保证原子性
// 这是 1122pc 中“幂等”的基础之一
ok, err := h.redis.SetNX(c.Request.Context(),
fmt.Sprintf(lock:stock:%s, skuID),
userID,
30*time.Second).Result()
if err != nil {
c.JSON(500, gin.H{error: Redis error})
return
}
if !ok {
// 锁已被占用，说明别人正在处理或上次未补偿
c.JSON(409, gin.H{error: Stock reserved by another user})
return
}
c.JSON(200, gin.H{status: reserved})
}
阶段二：二阶段确认 (Commit)
服务 A 协调所有服务都预占成功后，发起确认。
服务 B 收到 /commit 请求后，执行真正的库存扣减逻辑，并删除 Redis 锁。
// service-b/handler.go
func (h *Handler) CommitStock(c *gin.Context) {
skuID := c.Param(skuId)
lockKey := fmt.Sprintf(lock:stock:%s, skuID)
// 检查锁是否还在（防止超时后误操作）
val, _ := h.redis.Get(c.Request.Context(), lockKey).Result()
if val == {
c.JSON(400, gin.H{error: Lock expired or not found})
return
}
// 执行真正的业务逻辑：扣减库存
// 这里假设有一个数据库操作
// err := h.db.DecrementStock(skuID)
// 释放锁
h.redis.Del(c.Request.Context(), lockKey)
c.JSON(200, gin.H{status: committed})
}
阶段三 四：补偿与幂等 (Compensate Idempotent)
如果服务 C（支付）挂了，服务 A 必须调用服务 B 的 /rollback 接口。
/rollback 的逻辑和 /commit 类似，但只是释放锁，不扣库存。
幂等性怎么实现？
在 /commit 和 /rollback 中，不要仅依赖 Redis 锁。
引入一个唯一事务 ID (Transaction ID)。
每次操作前，查询 Redis 中的 tx:status:{txId}。
如果状态是 SUCCESS，直接返回成功，不再执行逻辑。
如果状态是 FAILED，直接返回失败。
如果状态不存在，执行逻辑，并写入状态。
// 幂等检查示例
func (h *Handler) IdempotentCheck(ctx context.Context, txID string) bool {
statusKey := fmt.Sprintf(tx:status:%s, txID)
val, err := h.redis.Get(ctx, statusKey).Result()
if err == redis.Nil {
return false // 未执行过
}
return val == SUCCESS
}
完整代码示例：跑通一个微服务闭环
下面是一个简化的、可运行的 Service B (库存服务) 完整代码。它包含了 1122pc 的核心接口。
请确保本地已安装 Go 和 Redis。
package main
import (
context
fmt
log
net/http
time
github.com/gin-gonic/gin
github.com/go-redis/redis/v8
)
type Handler struct {
redis *redis.Client
}
func main() {
// 初始化 Redis 客户端
rdb := redis.NewClient(redis.Options{
Addr: localhost:6379,
Password: ,
DB: 0,
})
ctx := context.Background()
pong, err := rdb.Ping(ctx).Result()
if err != nil {
log.Fatalf(Redis connection failed: %v, err)
}
log.Println(Redis Pong:, pong)
handler := Handler{redis: rdb}
r := gin.Default()
// 路由注册
r.POST(/reserve, handler.ReserveStock)
r.POST(/commit, handler.CommitStock)
r.POST(/rollback, handler.RollbackStock)
r.GET(/health, func(c *gin.Context) {
c.JSON(200, gin.H{status: ok})
})
log.Println(Service B starting on :8081)
r.Run(:8081)
}
// ReserveStock: 一阶段预占
func (h *Handler) ReserveStock(c *gin.Context) {
var req struct {
SkuID string `json:skuId binding:required`
UserID string `json:userId binding:required`
TxID string `json:txId binding:required`
}
if err := c.ShouldBindJSON(req); err != nil {
c.JSON(400, gin.H{error: Bad request})
return
}
lockKey := fmt.Sprintf(lock:stock:%s, req.SkuID)
txKey := fmt.Sprintf(tx:status:%s, req.TxID)
// 1. 幂等检查：如果已经成功，直接返回
if h.IsTxSuccess(c.Request.Context(), req.TxID) {
c.JSON(200, gin.H{status: reserved, idempotent: true})
return
}
// 2. 尝试加锁
ok, err := h.redis.SetNX(c.Request.Context(), lockKey, req.UserID, 30*time.Second).Result()
if err != nil {
c.JSON(500, gin.H{error: Redis error})
return
}
if !ok {
c.JSON(409, gin.H{error: Stock locked by another tx})
return
}
// 3. 标记事务为 PENDING (可选，用于监控)
h.redis.Set(c.Request.Context(), txKey, PENDING, 5*time.Minute)
c.JSON(200, gin.H{status: reserved})
}
// CommitStock: 二阶段确认
func (h *Handler) CommitStock(c *gin.Context) {
var req struct {
SkuID string `json:skuId binding:required`
TxID string `json:txId binding:required`
}
if err := c.ShouldBindJSON(req); err != nil {
c.JSON(400, gin.H{error: Bad request})
return
}
// 1. 幂等检查
if h.IsTxSuccess(c.Request.Context(), req.TxID) {
c.JSON(200, gin.H{status: committed, idempotent: true})
return
}
lockKey := fmt.Sprintf(lock:stock:%s, req.SkuID)
txKey := fmt.Sprintf(tx:status:%s, req.TxID)
// 2. 检查锁是否存在
val, _ := h.redis.Get(c.Request.Context(), lockKey).Result()
if val == {
// 锁超时了，这是异常情况，需要人工介入或告警
c.JSON(500, gin.H{error: Lock expired, manual intervention required})
return
}
// 3. 执行核心业务：扣减库存 (此处模拟)
log.Printf(Deducting stock for SKU: %s, Tx: %s, req.SkuID, req.TxID)
// db.Exec(UPDATE stock SET count = count - 1 WHERE sku_id = ?, req.SkuID)
// 4. 释放锁并标记事务成功
h.redis.Del(c.Request.Context(), lockKey)
h.redis.Set(c.Request.Context(), txKey, SUCCESS, 24*time.Hour)
c.JSON(200, gin.H{status: committed})
}
// RollbackStock: 两阶段补偿
func (h *Handler) RollbackStock(c *gin.Context) {
var req struct {
SkuID string `json:skuId binding:required`
TxID string `json:txId binding:required`
}
if err := c.ShouldBindJSON(req); err != nil {
c.JSON(400, gin.H{error: Bad request})
return
}
// 1. 幂等检查：如果已经回滚，直接返回
if h.IsTxRolledback(c.Request.Context(), req.TxID) {
c.JSON(200, gin.H{status: rolled_back, idempotent: true})
return
}
lockKey := fmt.Sprintf(lock:stock:%s, req.SkuID)
txKey := fmt.Sprintf(tx:status:%s, req.TxID)
// 2. 释放锁
// 注意：补偿阶段通常不检查锁归属，因为可能是超时导致的
h.redis.Del(c.Request.Context(), lockKey)
h.redis.Set(c.Request.Context(), txKey, ROLLED_BACK, 24*time.Hour)
log.Printf(Rollback stock for SKU: %s, Tx: %s, req.SkuID, req.TxID)
c.JSON(200, gin.H{status: rolled_back})
}
// 辅助函数
func (h *Handler) IsTxSuccess(ctx context.Context, txID string) bool {
val, _ := h.redis.Get(ctx, fmt.Sprintf(tx:status:%s, txID)).Result()
return val == SUCCESS
}
func (h *Handler) IsTxRolledback(ctx context.Context, txID string) bool {
val, _ := h.redis.Get(ctx, fmt.Sprintf(tx:status:%s, txID)).Result()
return val == ROLLED_BACK
}
运行步骤：
启动 Redis：docker run -p 6379:6379 redis
进入 service-b 目录，执行 go run main.go
使用 Postman 或 Curl 测试：
# 预占
curl -X POST http://localhost:8081/reserve -H Content-Type: application/json -d '{skuId:123,userId:u1,txId:tx-001}'
# 确认
curl -X POST http://localhost:8081/commit -H Content-Type: application/json -d '{skuId:123,txId:tx-001}'
常见报错：那些坑你踩过了吗
在实战中，以下三个报错占 1122pc 调试时间的 80%。
1. Error 110: Connection timed out
现象：服务 A 调用服务 B 超时。
原因：服务 B 的 Redis 操作阻塞了 HTTP 响应，或者网络抖动。
解决：
设置合理的 HTTP Client 超时时间（建议 500ms-1s）。
在 Redis 操作中使用 context.WithTimeout，确保 Redis 慢查询不会拖死整个 Goroutine。
关键点：微服务间调用必须设置超时，否则一个慢节点会拖垮整个链路。
2. Lock not found 在 Commit 阶段
现象：调用 /commit 时，Redis 里没有锁。
原因：一阶段预占时，锁的过期时间（TTL）设置得太短，或者中间件处理耗时超过了 TTL。
解决：
不要简单地延长 TTL。
引入看门狗机制 (Watchdog)：在持有锁期间，启动一个后台 Goroutine，每隔 TTL/3 的时间自动续期。
如果续期失败（比如服务挂了），则触发补偿逻辑。
3. Duplicate Key Error 在数据库层面
现象：虽然 Redis 锁成功了，但数据库插入订单时报错 Duplicate entry。
原因：Redis 锁释放后，另一个请求立刻进来，但前一个请求的数据库事务还没提交（或者网络延迟导致确认慢）。
解决：
数据库层面必须有唯一索引兜底。
1122pc 的最终一致性依赖于“应用层逻辑 + 数据库约束”的双重保障。Redis 锁只是第一道防线，数据库唯一索引是最后一道防线。
避坑清单：
永远不要信任客户端传来的 TxID，服务端必须生成或使用 UUID。
补偿逻辑必须幂等：回滚操作可能执行多次，必须确保多次执行结果一致。
监控不可少：记录每次 Reserve、Commit、Rollback 的日志，包含 TxID，方便链路追踪。
小结：从 1122pc 到职业进阶
写到这里，代码跑通了，逻辑闭环了。但我想多说两句。
1122pc 本身不是一个标准协议，它是一类工程实践模式。在 2026最新 的技术面试中，面试官问的不是“你知道 1122pc 是什么”，而是“如果让你设计一个秒杀系统，怎么保证不超卖？”
这时候，你能不能脱口而出：
前置限流（网关层）。
Redis 预扣减（一阶段）。
异步落库（二阶段确认）。
定时任务补偿（两阶段补偿）。
唯一索引兜底（两阶段幂等）。
如果你能结合 1122pc 的思想，把这个流程讲清楚，并指出其中的超时、网络分区、脏数据风险及应对方案，你的薪资区间至少上浮 20%。
关于证书与查询
很多培训机构会推销所谓的“1122pc 架构师认证”。在这里客观中立地提一句：
行业内没有官方的、全球认可的“1122pc 认证”。
市面上所谓的证书，多为培训机构内部颁发，仅在部分企业招聘时作为“学习能力”的参考，不具备行业通用性。
电子证书查询：如果是大厂（如阿里云、华为云）颁发的相关微服务认证，务必通过官网提供的唯一查询链接进行验证，警惕伪造证书。
建议：比起证书，一个能在 GitHub 上跑通的、包含监控和日志的 1122pc 实战 Demo，含金量远高于任何纸质证书。
薪资参考（2026 预测）
初级 (1-3年)：能读懂 1122pc 代码，处理简单 Bug。薪资区间 15k-25k (一线城市)。
中级 (3-5年)：能独立设计补偿逻辑，处理高并发下的锁竞争。薪资区间 30k-50k。
高级 (5年+)：能结合业务场景，权衡 1122pc 与 TCC、Saga 的优劣，进行架构选型。薪资区间 50k+。
技术没有银弹，1122pc 也是权衡的产物。它牺牲了部分实时性，换取了系统的高可用和可扩展性。理解这一点，你就超越了 90% 只会背八股文的人。
这个知识点你面试被问过吗？留言说说