Go 源码之 gorm 并发安全机制 clone

func main(){
  // 创建一个db句柄，此时db.clone=1
  db, err := gorm.Open(mysql.New(mysql.Config{
            }), &gorm.Config{})

}
func Open(dialector Dialector, opts ...Option) (db *DB, err error) {
    config := &Config{}
    .............

    db = &DB{Config: config, clone: 1}

    .............

    return
}

func main(){
  db,_:=gorm.Open(...) // db.clone = 1

  db.Where(...)  // 这里db的statement条件时不会生效的，db.clone=1 

  db=db.Where(...) // db.clone = 0, 内部调用了db.getInstance()，可以理解为返回了db.statement的副本，并发安全

}

// 传入的db的clone：
//  1.clone为0:
//        则返回原先的db，后续的db操作会影响原先的db，clone为原先的clone的值为0
//    2.clone为1:
//        返回一个带有db.Config的新db，且Statement为全新创建的，且clone值为0，后续的操作不会影响原先的db
//    3.clone为2:
//        返回一个带有db.Config的新db，且Statement为原先db的Statement，且clone值为0，后续的操作不会影响原先的db

func (db *DB) getInstance() *DB {
    if db.clone > 0 { // clone=1 or clone=2，修改db的一些参数，然后返回副本
        tx := &DB{Config: db.Config, Error: db.Error} // 复用db的配置创建新的db，tx.clone=0（int零值）

        if db.clone == 1 {
            // clone with new statement
            tx.Statement = &Statement{
                DB:        tx,
                ConnPool:  db.Statement.ConnPool,
                Context:   db.Statement.Context,
                Clauses:   map[string]clause.Clause{},
                Vars:      make([]interface{}, 0, 8),
                SkipHooks: db.Statement.SkipHooks,
            }
            if db.Config.PropagateUnscoped {
                tx.Statement.Unscoped = db.Statement.Unscoped
            }
        } else {
            // db.clone=2，则复制db的statement
            // with clone statement
            tx.Statement = db.Statement.clone()
            tx.Statement.DB = tx
        }
        return tx
    }
    // db.clone = 0，则直接返回当前db
    return db
}
// 代码简化
func (db *DB) getInstance() *DB {
    switch db.clone:
    case 0:
        return db
    case 1:
        return newStatement() // 一个全新的，空白的Statement
    case 2:
        return db.cloneStatement() // 将之前的Statement复制一份
}

func main(){
  db,_:=gorm.Open(...) // db.clone = 1

  db.Transaction(func(tx *gorm.DB) error {} // 非嵌套事务时内部调用 db.Begin()，Begin 内部通过 Session 返回 clone=2 的 tx
  // 嵌套事务时内部调用 fc(db.Session(&Session{NewDB: db.clone == 1}))

  db.Session(&gorm.Session{NewDB: true, Context: context.Background()}) // 带NewDB: true，则返回的db为全新的db，全新的statement，clone=1
}

// CloneDB 只会复制 db.Statement
func CloneDB(db *gorm.DB) *gorm.DB {
    // return db.WithContext(db.Statement.Context)
    return db.WithContext(context.Background())
}

// NewDB 完全新创建一个 DB
func NewDB(db *gorm.DB) *gorm.DB {
    // return db.Session(&gorm.Session{NewDB: true, Context: context.Background()})
    return db.Session(&gorm.Session{NewDB: true, Context: db.Statement.Context}) // 如果不想继承 context，则用 context.Background()
}

// CleanDB 使用原有 context 创建一个全新的 DB（不继承之前的 Where 等条件）
func CleanDB(db *gorm.DB) *gorm.DB {
    return db.Session(&gorm.Session{NewDB: true, Context: db.Statement.Context})  // 如果不想继承 context，则用 context.Background()
}

// 创建全局DB句柄,此时的clone=1
var db=dao.NewDevInventoryDBHelper().DB
func TestGorm(t *testing.T)  {
    db.Where("name=?","******") //clone=1会返回的新的db，如果不用新的变量接受，该where不做落在原的db上，
    db=db.Where("name=?","******") // clone=1，会返回一个新的db，但是会覆盖原先全局的db，导致后续的db操作都会带上此where的条件
    db2:=db.Where("name=?","******") // 该操作合理，返回新的db的clone=0，后续的操作可以不需要用变量再接收，也不会影响全局的db
    db2.Where("name=?","******")
}

// Where 内部会调用db.getInstance()
// 此时的db的clone为 1
db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})

// 安全的使用新初始化的 *gorm.DB
for i := 0; i < 100; i++ {
  // 每次返回的db都是clone为0的新db，所以是安全的
  go db.Where(...).First(&user)
}
// 此tx的clone=0
tx := db.Where("name = ?", "jinzhu")
// 不安全的复用 Statement
for i := 0; i < 100; i++ {
  // 此处的tx的clone为0，调用where之后会复用tx，导致所有的where都坐落在同一个tx上
  go tx.Where(...).First(&user)
}

ctx, _ := context.WithTimeout(context.Background(), time.Second)
// db.Session(&Session{Context: ctx}) 将clone重置为2
ctxDB := db.WithContext(ctx)
// 在 `新建会话方法` 之后是安全的
for i := 0; i < 100; i++ {
  // 每次返回的db都是clone为0的新db，所以是安全的
  go ctxDB.Where(...).First(&user)
}

ctx, _ := context.WithTimeout(context.Background(), time.Second)
ctxDB := db.Where("name = ?", "jinzhu").WithContext(ctx)
// 在 `新建会话方法` 之后是安全的
for i := 0; i < 100; i++ {
  go ctxDB.Where(...).First(&user) // `name = 'jinzhu'` 会应用到查询中
}

tx := db.Where("name = ?", "jinzhu").Session(&gorm.Session{})
// 在 `新建会话方法` 之后是安全的
for i := 0; i < 100; i++ {
  go tx.Where(...).First(&user) // `name = 'jinzhu'` 会应用到查询中
}

import "reflect"

func GetCloneStatus(db *gorm.DB) int {
    val := reflect.ValueOf(db).Elem()
    cloneField := val.FieldByName("clone")
    return int(cloneField.Int())
}

// 使用
status := GetCloneStatus(db)
fmt.Println("当前 clone 状态：", status) // 0, 1, 或 2