4. 缓存读写模式：Cache-Aside、Read-Through、Write-Through、Write-Behind 模式详解与 Go 代码实现

在分布式系统中，缓存与数据库之间的数据一致性是核心挑战。不同的缓存读写模式决定了系统在性能、一致性和可靠性之间的取舍。本章将深入剖析四种主流缓存模式：Cache-Aside、Read-Through、Write-Through 和 Write-Behind，并结合 Go 代码展示其实现细节与适用场景。

4.1 四种模式核心概念对比

4.2 Cache-Aside 模式详解与 Go 实现

Cache-Aside（旁路缓存）是应用最广泛的模式。应用代码显式管理缓存与数据库的交互。

4.2.1 读流程

1. 应用查询缓存，若命中则直接返回。
2. 若未命中，查询数据库。
3. 将查询结果写入缓存，设置过期时间。
4. 返回数据。

4.2.2 写流程

1. 应用更新数据库。
2. 删除缓存（或更新缓存，推荐删除以避免并发写导致的数据不一致）。

// CacheAside 示例：用户信息缓存
type UserService struct {
    db    *sql.DB
    cache *redis.Client
}

func (s *UserService) GetUser(ctx context.Context, userID string) (*User, error) {
    // 1. 读缓存
    key := "user:" + userID
    data, err := s.cache.Get(ctx, key).Bytes()
    if err == nil {
        user := &User{}
        if json.Unmarshal(data, user) == nil {
            return user, nil
        }
    }

    // 2. 缓存未命中，读数据库
    user, err := s.queryUserFromDB(ctx, userID)
    if err != nil {
        return nil, err
    }

    // 3. 回填缓存（设置过期时间 5 分钟）
    if bytes, err := json.Marshal(user); err == nil {
        s.cache.Set(ctx, key, bytes, 5*time.Minute)
    }

    return user, nil
}

func (s *UserService) UpdateUser(ctx context.Context, user *User) error {
    // 1. 更新数据库
    if err := s.updateUserInDB(ctx, user); err != nil {
        return err
    }

    // 2. 删除缓存（而非更新）
    key := "user:" + user.ID
    s.cache.Del(ctx, key)
    return nil
}

4.3 Read-Through 模式详解与 Go 实现

Read-Through 将“缓存未命中时回填数据库”的逻辑下沉到缓存层。应用只与缓存交互，缓存内部实现数据加载器（Loader）。

// Read-Through 模拟：自定义缓存封装
type ReadThroughCache struct {
    client *redis.Client
    loader func(ctx context.Context, key string) ([]byte, error) // 数据加载函数
}

func (c *ReadThroughCache) Get(ctx context.Context, key string) ([]byte, error) {
    data, err := c.client.Get(ctx, key).Bytes()
    if err == nil {
        return data, nil
    }

    // 缓存未命中，调用加载器
    data, err = c.loader(ctx, key)
    if err != nil {
        return nil, err
    }

    // 自动回填
    c.client.Set(ctx, key, data, 5*time.Minute)
    return data, nil
}

// 使用示例
cache := &ReadThroughCache{
    client: redisClient,
    loader: func(ctx context.Context, key string) ([]byte, error) {
        userID := strings.TrimPrefix(key, "user:")
        user, err := queryUserFromDB(ctx, userID)
        if err != nil {
            return nil, err
        }
        return json.Marshal(user)
    },
}

4.4 Write-Through 模式详解与 Go 实现

Write-Through 要求写操作必须同步写入缓存和数据库，两者都成功后才算完成。这保证了写路径的强一致性。

// Write-Through 实现：同步双写
type WriteThroughCache struct {
    client *redis.Client
    db     *sql.DB
}

func (c *WriteThroughCache) Set(ctx context.Context, key string, value []byte, ttl time.Duration) error {
    // 1. 先写数据库（事务内）
    tx, err := c.db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 假设存储的是序列化后的 JSON
    if _, err := tx.ExecContext(ctx, "INSERT INTO cache_store (cache_key, data) VALUES ($1, $2) ON CONFLICT (cache_key) DO UPDATE SET data = $2", key, value); err != nil {
        return err
    }

    // 2. 写缓存
    if err := c.client.Set(ctx, key, value, ttl).Err(); err != nil {
        return err // 缓存失败，回滚数据库
    }

    // 3. 提交数据库事务
    return tx.Commit()
}

4.5 Write-Behind 模式详解与 Go 实现

Write-Behind（也叫 Write-Back）将写操作先写入缓存，然后异步批量写入数据库。这极大提升了写吞吐，但引入了数据丢失风险。

// Write-Behind 实现：异步批量刷盘
type WriteBehindCache struct {
    client    *redis.Client
    db        *sql.DB
    buffer    chan WriteOp       // 写操作缓冲通道
    batchSize int
    flushInterval time.Duration
}

type WriteOp struct {
    Key   string
    Value []byte
}

func (c *WriteBehindCache) Start(ctx context.Context) {
    ticker := time.NewTicker(c.flushInterval)
    defer ticker.Stop()

    batch := make([]WriteOp, 0, c.batchSize)
    for {
        select {
        case op := <-c.buffer:
            batch = append(batch, op)
            if len(batch) >= c.batchSize {
                c.flushToDB(ctx, batch)
                batch = batch[:0]
            }
        case <-ticker.C:
            if len(batch) > 0 {
                c.flushToDB(ctx, batch)
                batch = batch[:0]
            }
        case <-ctx.Done():
            // 退出前强制刷盘
            if len(batch) > 0 {
                c.flushToDB(ctx, batch)
            }
            return
        }
    }
}

func (c *WriteBehindCache) flushToDB(ctx context.Context, batch []WriteOp) {
    // 批量写入数据库（使用事务或批量 INSERT）
    tx, _ := c.db.BeginTx(ctx, nil)
    for _, op := range batch {
        tx.ExecContext(ctx, "INSERT INTO cache_store (cache_key, data) VALUES ($1, $2) ON CONFLICT (cache_key) DO UPDATE SET data = $2", op.Key, op.Value)
    }
    tx.Commit()
}

func (c *WriteBehindCache) Set(ctx context.Context, key string, value []byte, ttl time.Duration) error {
    // 先写缓存
    if err := c.client.Set(ctx, key, value, ttl).Err(); err != nil {
        return err
    }
    // 异步入队
    c.buffer <- WriteOp{Key: key, Value: value}
    return nil
}

4.6 四种模式架构对比图

下图展示了四种模式在读写路径上的核心差异，帮助理解数据流向与一致性边界。

4.7 模式选型决策树

在实际项目中，可以根据以下决策树快速选择适合的缓存模式：

4.8 生产环境注意事项

• 缓存穿透： 查询一个不存在的数据，导致每次请求都穿透到 DB。解决方案：缓存空值（设置短 TTL）或使用布隆过滤器。
• 缓存击穿： 热点 key 在失效瞬间被大量并发请求打到 DB。解决方案：互斥锁（Mutex）或后台异步刷新。
• 缓存雪崩： 大量 key 在同一时间过期，导致 DB 压力激增。解决方案：设置随机 TTL，或使用多级缓存。
• 删除缓存失败： 在 Cache-Aside 写流程中，如果删除缓存失败，会导致脏数据。解决方案：使用重试机制或监听 binlog 异步删除。
• Write-Behind 数据丢失： 缓存宕机导致未刷盘的数据丢失。解决方案：结合 WAL 日志或消息队列的持久化机制。