Gorm 在同时更新多个表的同一事务和不同 goroutine 中出现错误

大家好，我们又见面了啊~本文《Gorm 在同时更新多个表的同一事务和不同 goroutine 中出现错误》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

我有这个代码示例

err = transaction.withtransaction(context.background(), func(txctx context.context) error {
  errorgroup := &errgroup.group{}
  errorgroup.go(func() error {
    return s.addtotable1(txctx, *model)
  })
  errorgroup.go(func() error {
    return s.updatetable1(txctx, *model)
  })
  errorgroup.go(func() error {
    return s.updatetable2(txctx, *model)
  })
  errorgroup.go(func() error {
    return s.updatetable3(txctx, *model)
  })
  errorgroup.go(func() error {
    return s.updatetable4(txctx, *model)
  })
  errorgroup.go(func() error {
    return s.updatetable5(txctx, *model)
  })
  if err := errorgroup.wait(); err != nil {
    transactionerror = err
    return err
  }
  }, func(trctx context.context) error {
    return transactionerror
  })

这里定义了withtransaction方法

type txkey struct{}

func injecttx(ctx context.context, tx *gorm.db) context.context {
   return context.withvalue(ctx, txkey{}, tx)
}

func extracttx(ctx context.context) *gorm.db {
   if tx, ok := ctx.value(txkey{}).(*gorm.db); ok {
      return tx
   }
   return nil
}

func withtransaction(ctx context.context, txfunc func(ctx context.context) error, trfunc func(ctx context.context) error) error {
   gormconnect := postgresgorm.dbconnection

   if gormconnect == nil {
      return commonerrors.internalservererror{
         errorresponse: commonerrors.errorresponse{
            message: "error",
         },
      }
   }

   tx := gormconnect.session(&gorm.session{skipdefaulttransaction: true}).begin()

   if err := tx.error; err != nil {
      return err
   }

   err := txfunc(injecttx(ctx, tx))

   if err != nil {
      tx.rollback()
      tx = postgresgorm.dbconnection.session(&gorm.session{skipdefaulttransaction: true}).begin()
      err = trfunc(injecttx(ctx, tx))
      tx.commit()
      return err
   }

   tx.commit()

   return nil

}

还有我们的 postgresdb 的 gorm 配置

var (
   dbconnection *gorm.db = nil
)

const (
   connectionfailedmsg = "postgres-gorm connection failed: %s"
)

// openconnection open postgres connection
func openconnection() {

   // postgresql connection, uncomment to use.
   // connection string format: user=user password=password host=/cloudsql/project_id:region_id:instance_id/[ dbname=db_name]
   dburi := fmt.sprintf("host=%s%s port=%d user=%s "+"password=%s dbname=%s sslmode=disable",
      configs.postgresqlgormconfigs.cloudsqlprefix, configs.postgresqlgormconfigs.host,
      configs.postgresqlgormconfigs.port, configs.postgresqlgormconfigs.user,
      configs.postgresqlgormconfigs.password, configs.postgresqlgormconfigs.dbname)
   config := &gorm.config{
      namingstrategy: schema.namingstrategy{
         tableprefix:   configs.postgresqlgormconfigs.tablegormprefix,
         singulartable: true,
      }}

   var err error

   dbconnection, err = gorm.open(postgres.open(dburi), config)

   if err != nil {
      panic(err)
   }

   sqldb, err := dbconnection.db()

   if err != nil {
      log.errorf(connectionfailedmsg, err)
      panic(err)
   }

   if configs.postgresqlgormconfigs.gormloggin {
      dbconnection.config.logger = gormlogger.default.logmode(gormlogger.info)
   }

   err = sqldb.ping()

   if err != nil {
      log.errorf(connectionfailedmsg, err)
   } else {
      log.info("postgres-gorm connection successfully established")

   }
}

这里是使用 gorm 更新表的方法示例

func (o ServiceImpl) UpdateTable1(ctx context.Context, model *model) (*model, error) {

   tx := transaction.ExtractTx(ctx)
   injectedTransaction := true

   if tx == nil {
      tx = postgresGorm.DbConnection.Begin()
      injectedTransaction = false
   }

   //Result
   queryResult := tx.Save(&model)

   // Error
   if queryResult.Error != nil {
      if !injectedTransaction {
         tx.Rollback()
      }
      errResp := commonerrors.ErrorResponse{
         Code:    "500",
         Message: "Error",
      }
      return nil, commonerrors.InternalServerError{ErrorResponse: errResp}
   }

   if !injectedTransaction {
      tx.Commit()
   }
   return shipDetail, nil
}

我们的问题是多个 goroutine 发生了一些问题，并且在使用此服务时我们随机收到此错误：驱动程序：连接不良但这完全是随机的，第一次尝试总是成功，之后失败一次，然后再次成功......你明白了。

我们尝试升级到最新版本的 gorm 和 gorm postgres 驱动程序，但它没有改变任何事情。阅读 gorm 文档，我们使用的所有方法都应该是线程安全的，所以我现在有点卡住了。如果我找到任何解决方案，我将更新该帖子。谢谢。

正确答案

我发布了当前对我们有效的答案，以防将来有人遇到此问题。主要问题是为所有线程重复使用相同的 gorm.session，因此我创建了一个通用的解决方法。

首先对 withtransaction 函数稍作修改：

func withtransaction(ctx context.context, txfunc func(ctx context.context) error, trfunc func(ctx context.context) error, nestedtx bool) error {
gormconnect := postgresgorm.dbconnection

if gormconnect == nil {
    return commonerrors.internalservererror{
        errorresponse: commonerrors.errorresponse{
            message: "error intentando conseguir la conexión con bbdd",
        },
    }
}

tx := gormconnect.session(&gorm.session{skipdefaulttransaction: true}).begin()

if err := tx.error; err != nil {
    return err
}

err := txfunc(injecttx(ctx, tx))

if err != nil {
    tx.rollback()
    tx = postgresgorm.dbconnection.session(&gorm.session{skipdefaulttransaction: true}).begin()
    err = trfunc(injecttx(ctx, tx))
    tx.commit()
    return err
}

if !nestedtx {
    tx.commit()
}

return nil
}

现在，如果我们有嵌套事务，它将不会提交。

然后我添加了这个函数来处理 errorgroup 并为每个 goroutine 创建一个新会话：

func routinetransaction(errorgroup *errgroup.group, transactions chan<- *gorm.db, subroutinefunctx func(txctx context.context) error) {
errorgroup.go(func() error {
    var routinetxerr error
    routinetxerr = withtransaction(context.background(), func(txctx context.context) error {
        transactions <- extracttx(txctx)
        routinetxerr = subroutinefunctx(txctx)
        return routinetxerr
    }, func(trctx context.context) error {
        return routinetxerr
    }, true)
    return routinetxerr
})


func routinestransactionscommit(transactions chan *gorm.db) {
close(transactions)
for tx := range transactions {
    tx.commit()
}
func routinestransactionsrollback(transactions chan *gorm.db) {
close(transactions)
for tx := range transactions {
    tx.rollback()
}
}

然后你只需在需要的地方使用它即可：

errorGroup := &errgroup.Group{}
    transactions := make(chan *gorm.DB, 6)
    transaction.RoutineTransaction(errorGroup, transactions, func(txCtx context.Context) error {
        return s.addToTable1(txCtx, *model)
    })
    transaction.RoutineTransaction(errorGroup, transactions, func(txCtx context.Context) error {
        return s.updateTable1(txCtx, *model)
    })
    transaction.RoutineTransaction(errorGroup, transactions, func(txCtx context.Context) error {
        return s.updateTable2(txCtx, *model)
    })
    transaction.RoutineTransaction(errorGroup, transactions, func(txCtx context.Context) error {
        return s.updateTable3(txCtx, *model)
    })
    if err := errorGroup.Wait(); err != nil {
        transaction.RoutinesTransactionsRollback(transactions)
        transactionError = err
        return err
    }
    transaction.RoutinesTransactionsCommit(transactions)

以上就是《Gorm 在同时更新多个表的同一事务和不同 goroutine 中出现错误》的详细内容，更多关于的资料请关注golang学习网公众号！