gorm中使用乐观锁

乐观锁简介

乐观锁(又称乐观并发控制)是一种常见的数据库并发控制策略。

乐观并发控制多数用于数据竞争(data race)不大、冲突较少的环境中，这种环境中，偶尔回滚事务的成本会低于读取数据时锁定数据的成本，因此可以获得比其他并发控制方法更高的吞吐量。 它的作用是防止并发更新数据库中的数据，从而避免数据的混乱。

实现乐观锁的核心要素

乐观锁由以下几个要素组成：

1. 在 table 中增加一列，用于记录此行数据的版本号

2. 更新数据前，先读取当前数据行的版本号

3. 更新时，对 UPDATE 语句作两处调整：

(1) WHERE 语句中加入版本号的比较条件，确保只有当前版本号与数据库中的版本号一致时才执行更新

WHERE ... and version = [current version]

(2) UPDATE 语句中递增版本号以保证每次更新后版本号都会变化

UPDATE set  ..., version = version + 1

1. SQL 执行以后需要检查更新行数是否为0，如果为0则说明有更新冲突，需要重试直到成功为止

在GORM中使用乐观锁

GORM是基于plugin架构的，GORM官方团队提供了这个plugin： go-gorm/optimisticlock。有了这个 plugin，在 GORM 中使用乐观锁就非常简单了。

安装这个插件：

go get -u gorm.io/plugin/optimisticlock

要使用乐观锁， 首先需要在 GORM model 中增加一个类型为 optimisticlock.Version 的版本字段：

import (
    "gorm.io/plugin/optimisticlock"
)
...
type Blog struct {
    Id      int
    Title string
    Content string
    // add version column to support optimistic lock 引入乐观锁版本号
    Version optimisticlock.Version
}

增加了这个字段以后，GORM 的更新操作就自动支持乐观锁了。

由于增加了版本判断，所以发生更新冲突时，更新行数将是0，这意味着此次更新失败，需要将此错误返回，通知调用方重试。

下面示例代码演示了如何更新Blog的标题字段：

func UpdateTitle(db *gorm.DB, id int, title string) error {
    blog := &Blog{}
    // load blog with latest version
    if err := db.Take(blog, id).Error; err != nil {
        return err
    }
    blog.Title = title

    // SQL: UPDATE blogs SET title = ?, version = version + 1 WHERE id = ? and version = ?
    // 更新用户信息，Gorm 会自动处理乐观锁逻辑
    result := db.Model(blog).Update("title", blog.Title)
    if err := result.Error; err != nil {
        return err
    }

    // version conflict occurred
    if result.RowsAffected == 0 {
        return ErrOptimisticLock
    }

    return nil
}

冲突处理策略

当乐观锁冲突发生时，开发者需要决定如何处理这种情况。通常，有以下几种策略：

1. 重试：重新读取数据，并尝试再次执行更新操作。
2. 回滚：取消当前操作，并通知用户操作失败。
3. 自定义逻辑：根据业务需求，执行特定的错误处理逻辑。

实际示例：乐观锁在并发场景中的应用

假设我们有一个在线购物系统，用户可以查看商品并将其添加到购物车。在这个场景中，我们希望确保用户在添加商品到购物车时，商品的库存数量是准确的。我们可以通过乐观锁来实现这一目标。

商品模型与库存管理

首先，我们定义一个商品模型，并在其中添加一个版本号字段：

type Product struct {
    ID        int
    Name      string
    Price     int
    Quantity  int
    Version   optimisticlock.Version // 版本号用于乐观锁
}

当用户尝试添加商品到购物车时，我们首先查询商品的当前库存和版本号，然后尝试更新库存数量。如果库存足够，我们减少库存数量并更新版本号。如果在这个过程中，库存被其他用户更新了，乐观锁会捕获到版本号的变化，并拒绝这次更新。

func AddToCart(db *gorm.DB, productID int, quantity int) (bool, error) {
    var product Product
    // 查询商品信息和版本号
    if err := db.First(&product, "id = ?", productID).Error; err != nil {
        return false, err
    }

    // 检查库存是否足够
    if product.Quantity < quantity {
        return false, nil // 库存不足
    }

    // 更新库存和版本号
    if err := db.Model(&product).Update("quantity", product.Quantity-quantity).Error; err != nil {
        if errors.Is(err, optimisticlock.ErrOptimisticLock) {
            // 乐观锁冲突，需要重新尝试
            return false, nil
        }
        return false, err
    }
    return true, nil
}

在这个示例中，我们通过乐观锁确保了在并发环境下，商品库存的更新是安全的。如果发生冲突，我们可以通知用户重新尝试操作，或者采取其他补救措施。

go-gorm/optimisticlock 影响了哪些方法

由于 go-gorm/optimisticlock 是用 GORM plugin 机制实现的。 所以所有支持plugin的更新和插入方法会受影响，这包括：

1. Update
2. Updates
3. Create

有些方法不支持plugin，因此不会受影响：

1. UpdateColumn
2. UpdateColumns

注意: DB.Save与此plugin有冲突

前面列出的方法不包括 DB.Save，因为它在特定场景下不能正常工作。

DB.Save 支持plugin，所以它生成的SQL也会被自动修改。

我们知道 Save 既支持数据插入也支持更新：

• 当 model 主键为空值时，Save 的行为与 Create 相同，这种情况下没有问题，
• 当 model 主键不为空时，Save 会更新全部字段。这时会出现bug

下面我们尝试用 DB.Save 来更新全部字段，用这个示例说明问题所在:

func UpdateAll(db *gorm.DB, blog *Blog) error {
    // save blog
    // bug: will return primary key duplicate error in case update conflict
    result := db.Save(blog)
    if err := result.Error; err != nil {
        return err
    }

    // bug: never execute
    if result.RowsAffected == 0 {
        return ErrOptimisticLock
    }
    return nil
}

当发生更新冲突时，UpdateAll 并没有返回我们期望的 ErrOptimisticLock，而是返回了 duplicate key value violates ... 错误。

这是相同主键重复插入时才会出的错误。

为什么会这样？ 答案在 DB.Save 的源码里：

// Save update value in database, if the value doesn't have primary key, will insert it
func (db *DB) Save(value interface{}) (tx *DB) {
   ...
   tx = tx.callbacks.Update().Execute(tx)

   if tx.Error == nil && tx.RowsAffected == 0 && !tx.DryRun && !selectedUpdate {
      result := reflect.New(tx.Statement.Schema.ModelType).Interface()
      if result := tx.Session(&Session{}).Limit(1).Find(result); result.RowsAffected == 0 {
          return tx.Create(value)
      }
   }
   ...
}

对照下面 DB.Save 的流程图，会发现问题的根源在 tx.RowsAffected == 0。

发生更新冲突时 RowsAffected 将是 0。

而这会导致 DB.Save 再次执行 Insert 操作，此时的主键不是空，所以会出现重复主键的错误。

要避免此问题，需要用 Updates 替换 Save。

同时要注意 Updates 默认只更新"非空"字段，需要加上 db.Select("*") 才能更新全部字段。

修正后的方法如下：

func UpdateAll(db *gorm.DB, blog *Blog) error {
    // make sure update all fields
    result := db.Select("*").Updates(blog)
    if err := result.Error; err != nil {
        return err
    }

    if result.RowsAffected == 0 {
        return ErrOptimisticLock
    }
    return nil
}