xorm 框架在事务中使用行级锁 forupdate,核心做法是调用 session.forupdate() 方法开启事务会话,随后执行查询操作。该操作会生成带有 for update 后缀的 sql 语句,锁定查询到的数据行,防止其他事务修改或删除这些行,直到当前事务提交或回滚。

如何确保 ForUpdate 生效并避免死锁
要确保 ForUpdate 真正生效,必须满足两个条件:一是数据库引擎支持行级锁(如 MySQL 的 InnoDB),二是查询必须通过索引进行。如果没有索引,InnoDB 会退化为表级锁,严重影响并发性能甚至导致死锁。此外,必须在同一个事务会话中执行查询和更新操作,否则锁可能失效或提前释放。

package main
import (
"fmt"
"log"
"xorm.io/xorm"
_ "github.com/go-sql-driver/mysql"
)
type User struct {
Id int64 `xorm:"pk autoincr"`
Name string `xorm:"unique index"`
Age int
}
func main() {
engine, err := xorm.NewEngine("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
if err != nil {
log.Fatal(err)
}
defer engine.Close()
// 创建会话
session := engine.NewSession()
defer session.Close()
// 开启事务
if err := session.Begin(); err != nil {
log.Fatal(err)
}
// 使用 ForUpdate 查询
var user User
has, err := session.ForUpdate().Where("name = ?", "alice").Get(&user)
if err != nil {
session.Rollback()
log.Fatal(err)
}
if !has {
session.Rollback()
return
}
// 模拟业务逻辑:更新年龄
user.Age += 1
_, err = session.Id(user.Id).Update(&user)
if err != nil {
session.Rollback()
log.Fatal(err)
}
// 提交事务
if err := session.Commit(); err != nil {
log.Fatal(err)
}
fmt.Println("Transaction committed successfully.")
}
ForUpdate 与乐观锁的区别及适用场景
ForUpdate 属于悲观锁机制,它在读取数据时就加锁,适合写多读少、冲突概率高的场景。相比之下,XORM 也支持乐观锁,通常通过版本号字段实现,适合读多写少、冲突较少的场景。选择哪种方式取决于业务对一致性和并发的要求。如果使用 ForUpdate,务必注意锁的粒度,尽量缩小查询范围,减少持有锁的时间。

package main
import (
"fmt"
"log"
"time"
"xorm.io/xorm"
_ "github.com/go-sql-driver/mysql"
)
type Product struct {
Id int64 `xorm:"pk autoincr"`
Name string `xorm:"unique index"`
Stock int
Version int `xorm:"version"`
}
func testOptimisticLock(engine *xorm.Engine) {
// 假设库存为 10
product := &Product{Name: "laptop", Stock: 10, Version: 0}
engine.Insert(product)
// 模拟两个并发请求
go func() {
session := engine.NewSession()
defer session.Close()
if err := session.Begin(); err != nil {
log.Fatal(err)
}
var p Product
session.Get(&p)
p.Stock--
_, err := session.Id(p.Id).Update(&p)
if err != nil {
session.Rollback()
fmt.Println("Concurrency conflict detected in goroutine 1")
return
}
session.Commit()
fmt.Println("Goroutine 1 updated stock to", p.Stock)
}()
go func() {
time.Sleep(time.Millisecond * 100) // 稍微延迟
session := engine.NewSession()
defer session.Close()
if err := session.Begin(); err != nil {
log.Fatal(err)
}
var p Product
session.Get(&p)
p.Stock--
_, err := session.Id(p.Id).Update(&p)
if err != nil {
session.Rollback()
fmt.Println("Concurrency conflict detected in goroutine 2")
return
}
session.Commit()
fmt.Println("Goroutine 2 updated stock to", p.Stock)
}()
time.Sleep(time.Second * 2)
}
func main() {
engine, _ := xorm.NewEngine("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
defer engine.Close()
testOptimisticLock(engine)
}
ForUpdate 在子查询中的行为限制
在 XORM 中,如果尝试在子查询中使用 ForUpdate,大多数数据库不支持这种语法。例如,MySQL 不允许在子查询中直接加锁。因此,如果需要基于子查询结果进行更新,应先在外层查询获取 ID 列表,再对这些 ID 进行 ForUpdate 查询。这样可以避免语法错误,同时保证数据一致性。











