gorm操作sqlite3，高并发读写如何避免锁库？

1. 场景

这两天一直被这个sqlit3困扰，起因是项目中需要有这样一个中间，中间件承担着API角色和流量转发的角色，需要接收来自至少300个agent的请求数据，和健康检测的请求。 所以当即想到用go来实现，因为数据教训，不考虑使用pg大型数据库，所以就选择了轻量化的sqlite数据库。程序很快就开发完了。上线，运行几个节点，数据读写都未发生异常，但是当测试数据到达一定量级后，会出现database is locked错误。 查了些资料，大意是sqlite并发读支持不错，但是并发写就不太友好，所以有了此次的实践。
ps: 部分代码来自于chatGPT,不得不说chatGPT太香了。
在 Gorm 中操作 SQLite3数据库时，由于 SQLite3 的写锁机制是针对整个数据库而不是单个表或行，因此高并发读写可能会导致锁库的情况。

2. 如何避免

为了避免锁库问题，可以采用以下几种方法：

• 使用 WAL 模式
  使用 SQLite3 的 WAL（Write-Ahead Logging）模式可以显著降低锁库的概率。在 WAL 模式下，读操作不会阻塞写操作，写操作也不会阻塞读操作，因此可以实现高并发的读写操作。
  可以在 Gorm 中使用以下代码开启 WAL 模式：
  1. import "gorm.io/driver/sqlite"
  2. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{
  3.      DSN: "mode=wal",
  4. })
  6. // 上面这种参数设置方式已经不适用新的设置方法如下
  7. if Inst, err = gorm.Open(sqlite.Open(dsn), gormConfig); err == nil {
  8.              // 启用 WAL 模式
  9.              _ = Inst.Exec("PRAGMA journal_mode=WAL;")
  10.              //_ = Inst.Exec("PRAGMA journal_size_limit=104857600;")
  11.            //_ = Inst.Exec("PRAGMA busy_timeout=999999;")
  12. }

  复制代码
• 合理控制事务范围
  在进行高并发读写操作时，需要注意事务范围的控制，尽可能缩小事务的范围，减少写锁的占用时间。例如，在进行批量写入操作时，可以将每次写入拆分为多个事务，以减少写锁的占用时间。
  
• 使用缓存
  使用缓存可以减少对数据库的读操作，从而减少锁库的概率。可以使用第三方缓存库（如 Redis）来实现缓存功能。
  
• 增加数据库连接数
  增加数据库连接数可以提高数据库的并发处理能力，减少锁库的概率。可以在 Gorm 中使用以下代码来增加数据库连接数：
  1. import "gorm.io/driver/sqlite"
  3. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  5. sqlDB, dbError := db.DB()
  6. if dbError != nil {
  7.     return nil, fmt.Errorf("failed to create sqlDB")
  8. }
  10. // SetMaxIdleConns 设置空闲连接池中连接的最大数量
  11. sqlDB.SetMaxIdleConns(10)
  13. // SetMaxOpenConns 设置打开数据库连接的最大数量。
  14. sqlDB.SetMaxOpenConns(100)'

  复制代码
  需要注意的是，增加连接数也会增加服务器的负载，因此需要根据实际情况进行调整。
  综上所述，通过采用合适的锁机制、事务控制、缓存和连接数设置等措施，可以有效避免 SQLite3 数据库的锁库问题。
  

3. 完整的代码示例

• 示例1：
  下面是一个完整的 Gorm 操作 SQLite3 数据库的代码示例，其中包括开启 WAL 模式、控制事务范围、使用缓存和增加数据库连接数等措施，以避免锁库问题。
  1. import (
  2.     "gorm.io/driver/sqlite"
  3.     "gorm.io/gorm"
  4.     "time"
  5. )
  7. // 定义模型结构体
  8. type User struct {
  9.     ID        uint
  10.     Name      string
  11.     Age       uint8
  12.     CreatedAt time.Time
  13.     UpdatedAt time.Time
  14. }
  16. // 初始化数据库连接
  17. func InitDB() (*gorm.DB, error) {
  18.     db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{
  19.         // 开启 WAL 模式
  20.         DSN: "mode=wal",
  21.         // 增加最大连接数为 100
  22.         MaxOpenConns: 100,
  23.     })
  24.     if err != nil {
  25.         return nil, err
  26.     }
  27.     // 设置数据库连接池参数
  28.     sqlDB, err := db.DB()
  29.     if err != nil {
  30.         return nil, err
  31.     }
  32.     sqlDB.SetMaxIdleConns(10)
  33.     sqlDB.SetMaxOpenConns(100)
  34.     sqlDB.SetConnMaxLifetime(time.Hour)
  36.     return db, nil
  37. }
  39. // 定义批量写入函数
  40. func BatchInsertUsers(db *gorm.DB, users []User) error {
  41.     // 每次写入 1000 条数据
  42.     batchSize := 1000
  43.     batchCount := (len(users) + batchSize - 1) / batchSize
  44.     for i := 0; i < batchCount; i++ {
  45.         start := i * batchSize
  46.         end := (i + 1) * batchSize
  47.         if end > len(users) {
  48.             end = len(users)
  49.         }
  50.         batch := users[start:end]
  51.         // 启用事务
  52.         tx := db.Begin()
  53.         if err := tx.Error; err != nil {
  54.             return err
  55.         }
  56.         if err := tx.Create(&batch).Error; err != nil {
  57.             tx.Rollback()
  58.             return err
  59.         }
  60.         // 提交事务
  61.         if err := tx.Commit().Error; err != nil {
  62.             return err
  63.         }
  64.     }
  65.     return nil
  66. }
  68. // 查询用户信息
  69. func GetUsers(db *gorm.DB) ([]User, error) {
  70.     var users []User
  71.     // 使用缓存，减少对数据库的读操作
  72.     err := db.Cache(&users).Find(&users).Error
  73.     if err != nil {
  74.         return nil, err
  75.     }
  76.     return users, nil
  77. }
  79. // 示例代码
  80. func main() {
  81.     // 初始化数据库连接
  82.     db, err := InitDB()
  83.     if err != nil {
  84.         panic(err)
  85.     }
  86.     defer db.Close()
  88.     // 批量插入数据
  89.     users := []User{}
  90.     for i := 0; i < 100000; i++ {
  91.         user := User{
  92.             Name:      "user_" + string(i),
  93.             Age:       uint8(i % 100),
  94.             CreatedAt: time.Now(),
  95.             UpdatedAt: time.Now(),
  96.         }
  97.         users = append(users, user)
  98.     }
  99.     err = BatchInsertUsers(db, users)
  100.     if err != nil {
  101.         panic(err)
  102.     }
  104.     // 查询数据
  105.     users, err = GetUsers(db)
  106.     if err != nil {
  107.         panic(err)
  108.     }
  109.     for _, user := range users {
  110.         fmt.Println(user)
  111.     }
  112. }

  复制代码
• 示例2：使用 WAL 模式和事务控制来避免锁库问题：
  1. package main
  3. import (
  4.     "fmt"
  5.     "gorm.io/driver/sqlite"
  6.     "gorm.io/gorm"
  7. )
  9. type User struct {
  10.     ID   uint
  11.     Name string
  12. }
  14. func main() {
  15.     // 创建 SQLite3 数据库连接
  16.     db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{
  17.         // 开启 WAL 模式
  18.         DSN: "mode=wal",
  19.     })
  20.     if err != nil {
  21.         panic("failed to connect database")
  22.     }
  23.     // 设置连接池大小
  24.     sqlDB, err := db.DB()
  25.     if err != nil {
  26.         panic("failed to set database pool size")
  27.     }
  28.     sqlDB.SetMaxIdleConns(10)
  29.     sqlDB.SetMaxOpenConns(100)
  31.     // 自动迁移 User 模型对应的表
  32.     err = db.AutoMigrate(&User{})
  33.     if err != nil {
  34.         panic("failed to migrate table")
  35.     }
  37.     // 并发写入 1000 条数据
  38.     for i := 0; i < 1000; i++ {
  39.         go func(i int) {
  40.             err := db.Transaction(func(tx *gorm.DB) error {
  41.                 user := User{Name: fmt.Sprintf("user_%d", i)}
  42.                 result := tx.Create(&user)
  43.                 return result.Error
  44.             })
  45.             if err != nil {
  46.                 fmt.Printf("failed to write data: %v\n", err)
  47.             }
  48.         }(i)
  49.     }
  51.     // 并发读取数据
  52.     for i := 0; i < 1000; i++ {
  53.         go func() {
  54.             var users []User
  55.             err := db.Transaction(func(tx *gorm.DB) error {
  56.                 result := tx.Find(&users)
  57.                 return result.Error
  58.             })
  59.             if err != nil {
  60.                 fmt.Printf("failed to read data: %v\n", err)
  61.             } else {
  62.                 fmt.Printf("read %d records\n", len(users))
  63.             }
  64.         }()
  65.     }
  67.     // 等待 10 秒钟，以便所有的写入和读取操作都完成
  68.     time.Sleep(10 * time.Second)
  69. }   

  复制代码
  在这个代码示例中，我们首先使用 gorm.Open 函数创建了一个 SQLite3 数据库连接，并设置了连接池大小和 WAL 模式。然后，我们使用 d    b.AutoMigrate 函数自动迁移 User 模型对应的表。
  接着，我们在循环中并发地写入 1000 条数据，并使用事务控制来控制事务的范围。每个写入操作都会创建一个 User 对象，并使用 tx.Create 函数将其写入数据库。
  然后，我们在另一个循环中并发地读取数据，并使用事务控制来控制事务的范围。每个读取操作都会使用 tx.Find 函数从数据库中读取所有的 User 记录，并打印出读取的记录数。
  最后，我们等待 10 秒钟，以便所有的写入和读取操作都完成。在这个示例中，我们使用了并发的写入和读取
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！