-- 排他鎖（寫鎖）：其他事務不能讀（除非快照讀）、不能寫
SELECT * FROM accounts WHERE id = 1 FOR UPDATE;
-- 共享鎖（讀鎖）：允許多個事務讀，但阻止寫
SELECT * FROM accounts WHERE id = 1 FOR SHARE;

func TransferHandler(c *gin.Context) {
    tx := db.Begin()
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
        }
    }()
    var fromAccount Account
    // 悲觀鎖：鎖定 from 賬戶
    if err := tx.Set("gorm:query_option", "FOR UPDATE").
        Where("id = ?", 1).First(&fromAccount).Error; err != nil {
        tx.Rollback()
        c.JSON(400, gin.H{"error": "賬戶不存在"})
        return
    }
    var toAccount Account
    if err := tx.Set("gorm:query_option", "FOR UPDATE").
        Where("id = ?", 2).First(&toAccount).Error; err != nil {
        tx.Rollback()
        c.JSON(400, gin.H{"error": "目標賬戶不存在"})
        return
    }
    if fromAccount.Balance < 100 {
        tx.Rollback()
        c.JSON(400, gin.H{"error": "余額不足"})
        return
    }
    fromAccount.Balance -= 100
    toAccount.Balance += 100
    tx.Save(&fromAccount)
    tx.Save(&toAccount)
    tx.Commit()
    c.JSON(200, gin.H{"msg": "轉(zhuǎn)賬成功"})
}

CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    stock INT,
    version INT DEFAULT 0
);

UPDATE products 
SET stock = stock - 1, version = version + 1 
WHERE id = 1 AND version = 5;  -- 只有 version 未變才更新

type Product struct {
    ID      uint `gorm:"primarykey"`
    Name    string
    Stock   int
    Version uint32 // GORM 自動識別為樂觀鎖字段
}
func ReduceStock(c *gin.Context) {
    var product Product
    id := c.Param("id")
    // 第一次讀取
    if err := db.First(&product, id).Error != nil {
        c.JSON(404, gin.H{"error": "商品不存在"})
        return
    }
    // 業(yè)務邏輯：扣減庫存
    if product.Stock <= 0 {
        c.JSON(400, gin.H{"error": "庫存不足"})
        return
    }
    // 嘗試更新（GORM 自動在 WHERE 中加入 version 條件）
    product.Stock--
    result := db.Save(&product)
    if result.Error != nil {
        c.JSON(500, gin.H{"error": "數(shù)據(jù)庫錯誤"})
        return
    }
    if result.RowsAffected == 0 {
        // 樂觀鎖失?。喊姹静黄ヅ?
        c.JSON(409, gin.H{"error": "庫存已被其他請求修改，請重試"})
        return
    }
    c.JSON(200, gin.H{"msg": "扣減成功", "stock": product.Stock})
}

用戶請求
    │
    ▼
[ Gin Web 服務 ] ←─┐
    │              │
    ▼              │
[ Redis 預減庫存 ] │ ←─ 庫存校驗 & 原子扣減（Lua 腳本）
    │              │
    ▼              │
[ 發(fā)送消息到 MQ ] ─┘ → [ Kafka / RabbitMQ / RocketMQ ]
    │
    ▼
[ 異步消費服務 ]
    │
    ▼
[ MySQL 落庫 ] ←─ 訂單創(chuàng)建、庫存最終扣減、記錄日志
    │
    ▼
[ 返回結(jié)果給用戶（可延遲）]

// 初始化庫存（管理后臺或定時任務調(diào)用）
redisClient.Set(ctx, "stock:product:1001", 100, 0)

-- stock_decrease.lua
local key = KEYS[1]
local userId = ARGV[1]
-- 1. 檢查是否已搶購（防重）
if redis.call("EXISTS", "seckill:user:" .. userId .. ":product:" .. string.match(key, ":(%d+)$")) == 1 then
    return -2  -- 已參與
end
-- 2. 獲取當前庫存
local stock = tonumber(redis.call("GET", key))
if not stock or stock <= 0 then
    return -1  -- 庫存不足
end
-- 3. 扣減庫存
redis.call("DECR", key)
-- 4. 記錄用戶已參與（防重，TTL 可選）
redis.call("SET", "seckill:user:" .. userId .. ":product:" .. string.match(key, ":(%d+)$"), "1", "EX", 3600)
return stock - 1

// main.go 或 handler/seckill.go
func SeckillHandler(c *gin.Context) {
    userID := c.GetString("user_id") // 假設已鑒權(quán)
    productID := c.Param("product_id")
    // 構(gòu)造 Redis Key
    stockKey := fmt.Sprintf("stock:product:%s", productID)
    userProductKey := fmt.Sprintf("seckill:user:%s:product:%s", userID, productID)
    // 執(zhí)行 Lua 腳本
    result, err := redisClient.Eval(
        ctx,
        luaScript,           // 上述 Lua 腳本內(nèi)容
        []string{stockKey},
        userID,
    ).Result()
    if err != nil {
        c.JSON(500, gin.H{"error": "系統(tǒng)繁忙"})
        return
    }
    switch ret := result.(type) {
    case int64:
        if ret == -1 {
            c.JSON(400, gin.H{"error": "庫存不足"})
            return
        }
        if ret == -2 {
            c.JSON(400, gin.H{"error": "您已參與過本次秒殺"})
            return
        }
    default:
        c.JSON(500, gin.H{"error": "未知錯誤"})
        return
    }
    // 成功！發(fā)送消息到 MQ（異步落庫）
    msg := SeckillMessage{
        UserID:    userID,
        ProductID: productID,
        Timestamp: time.Now(),
    }
    // 序列化并發(fā)送到 Kafka / RabbitMQ
    if err := mqProducer.Send("seckill_queue", msg); err != nil {
        // 注意：此處即使 MQ 發(fā)送失敗，Redis 已扣減，需有補償機制！
        log.Printf("MQ send failed: %v", err)
        // 可考慮回滾 Redis（復雜），或依賴后續(xù)對賬
    }
    // 立即返回用戶“搶購成功，請等待訂單生成”
    c.JSON(200, gin.H{
        "msg": "搶購成功！正在生成訂單...",
        "queue_status": "processing",
    })
}

// worker/seckill_worker.go
func StartSeckillWorker() {
    for msg := range mqConsumer.Subscribe("seckill_queue") {
        var seckillMsg SeckillMessage
        if err := json.Unmarshal(msg, &seckillMsg); err != nil {
            continue
        }
        // 開啟事務，落庫
        tx := db.Begin()
        defer tx.Rollback()
        // 1. 再次校驗（兜底）：MySQL 中庫存是否足夠？
        var product Product
        if err := tx.Where("id = ? AND stock > 0", seckillMsg.ProductID).First(&product).Error; err != nil {
            log.Printf("MySQL 庫存不足或商品不存在: %v", seckillMsg)
            continue // 丟棄消息 or DLQ
        }
        // 2. 創(chuàng)建訂單
        order := Order{
            UserID:    seckillMsg.UserID,
            ProductID: seckillMsg.ProductID,
            Status:    "created",
        }
        if err := tx.Create(&order).Error != nil {
            continue
        }
        // 3. 扣減 MySQL 庫存
        if err := tx.Model(&Product{}).
            Where("id = ? AND stock = ?", seckillMsg.ProductID, product.Stock).
            Update("stock", gorm.Expr("stock - 1")).Error; err != nil {
            continue
        }
        tx.Commit()
        log.Printf("訂單創(chuàng)建成功: %v", order.ID)
    }
}