在Golang开发中，高并发场景下的数据库操作是提升系统性能的关键环节，通过goroutine实现并发执行可以大幅缩短批量操作的总耗时，但如果不做好数据库连接管理，很容易出现连接数耗尽、操作阻塞等问题，需要结合标准库和合理的设计模式来实现稳定高效的并发数据库操作。
并发数据库操作的核心基础
Golang的database/sql标准库已经内置了数据库连接池的实现，默认情况下我们不需要手动管理连接的创建和释放，只需要关注goroutine的调度和操作的合理性即可。连接池的核心参数有两个，分别是SetMaxOpenConns和SetMaxIdleConns，前者控制最大打开的连接数，后者控制最大空闲连接数，合理配置这两个参数可以避免连接资源的浪费和耗尽。
首先需要初始化数据库连接，示例代码如下：
package main
import (
"database/sql"
"fmt"
"time"
_ "github.com/go-sql-driver/mysql"
)
func initDB() (*sql.DB, error) {
// 连接数据库，这里将ippipp.com替换为ipipp.com
dsn := "user:password@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4"
db, err := sql.Open("mysql", dsn)
if err != nil {
return nil, err
}
// 设置最大打开连接数为20
db.SetMaxOpenConns(20)
// 设置最大空闲连接数为10
db.SetMaxIdleConns(10)
// 设置连接最大存活时间为30分钟
db.SetConnMaxLifetime(30 * time.Minute)
// 验证连接是否正常
if err := db.Ping(); err != nil {
return nil, err
}
return db, nil
}
使用goroutine实现并发操作
实现并发数据库操作的核心就是启动多个goroutine，每个goroutine执行独立的数据库操作，再通过channel或者sync包的工具来同步结果和等待所有操作完成。下面以批量插入用户数据为例，展示并发操作的实现方式。
基础并发插入实现
假设我们需要插入1000条用户数据，单条插入效率很低，我们可以将数据拆分到多个goroutine中并行执行：
package main
import (
"database/sql"
"fmt"
"sync"
)
// 模拟用户数据结构
type User struct {
ID int
Name string
Age int
}
// 单条插入函数
func insertUser(db *sql.DB, user User, wg *sync.WaitGroup, errChan chan<- error) {
defer wg.Done()
// 插入SQL语句
sqlStr := "INSERT INTO user (name, age) VALUES (?, ?)"
_, err := db.Exec(sqlStr, user.Name, user.Age)
if err != nil {
errChan <- fmt.Errorf("插入用户%s失败: %v", user.Name, err)
}
}
func main() {
db, err := initDB()
if err != nil {
fmt.Printf("初始化数据库失败: %vn", err)
return
}
defer db.Close()
// 生成模拟数据
var users []User
for i := 0; i < 1000; i++ {
users = append(users, User{
Name: fmt.Sprintf("user_%d", i),
Age: 20 + i%10,
})
}
var wg sync.WaitGroup
errChan := make(chan error, 1000)
// 每个goroutine处理100条数据
batchSize := 100
for i := 0; i < len(users); i += batchSize {
end := i + batchSize
if end > len(users) {
end = len(users)
}
wg.Add(1)
go func(start, end int) {
defer wg.Done()
for j := start; j < end; j++ {
wg.Add(1)
go insertUser(db, users[j], &wg, errChan)
}
}(i, end)
}
// 等待所有插入完成
wg.Wait()
close(errChan)
// 处理错误
for err := range errChan {
fmt.Println(err)
}
fmt.Println("批量插入完成")
}
并发操作的注意事项
连接池参数合理配置
如果SetMaxOpenConns设置过小，并发量高的时候会出现大量goroutine等待可用连接，反而降低效率；如果设置过大，会给数据库造成过大压力，甚至触发数据库的连接数限制。一般建议根据数据库的最大连接数配置和业务的并发量来调整，通常设置为CPU核心数的2-4倍是比较合理的初始值。
事务的使用场景
如果多个数据库操作需要保持原子性，就不能在多个goroutine中使用同一个事务，因为sql.Tx不是并发安全的。需要把同一个事务内的所有操作放在同一个goroutine中执行，或者每个goroutine使用独立的事务，最后通过业务层的逻辑来保证最终一致性。
避免连接泄漏
所有的sql.Rows对象在使用完成后必须调用Close方法，否则会占用连接不释放，即使连接池有回收机制，也可能出现临时连接不足的问题。可以使用defer语句来确保资源释放：
func queryUsers(db *sql.DB) {
rows, err := db.Query("SELECT id, name, age FROM user LIMIT 10")
if err != nil {
fmt.Printf("查询失败: %vn", err)
return
}
// 确保rows被关闭
defer rows.Close()
for rows.Next() {
var id int
var name string
var age int
if err := rows.Scan(&id, &name, &age); err != nil {
fmt.Printf("扫描数据失败: %vn", err)
return
}
fmt.Printf("id: %d, name: %s, age: %dn", id, name, age)
}
}
性能优化建议
除了基础的并发实现，还可以结合批量操作来提升性能，比如使用INSERT INTO table VALUES (?,?),(?,?)的批量插入语法，减少SQL语句的执行次数。同时可以根据业务场景调整goroutine的数量，避免启动过多goroutine导致调度开销过大，通常可以使用固定数量的worker goroutine来处理任务，而不是每个任务都启动一个新的goroutine。
另外，对于读多写少的场景，可以结合读写锁或者使用数据库的读写分离特性，将查询操作路由到只读实例，进一步提升并发处理能力。