Go database/sql 事务与连接管理深度解析：避免“连接过多”错误

Begin Transaction failed. Error = Error 1040: Too many connections

// 错误示例：使用原始SQL命令提交事务
_, oOsError = poDbTxn.Exec("COMMIT") // 这种方式是错误的

var db *sql.DB // 全局或单例模式
func initDB() {
    var err error
    db, err = sql.Open("postgres", "user=admin dbname=testdb password=admin sslmode=disable")
    if err != nil {
        log.Fatalf("Failed to open database: %v", err)
    }
    // 可选：配置连接池参数
    db.SetMaxOpenConns(25) // 最大打开连接数
    db.SetMaxIdleConns(10) // 最大空闲连接数
    db.SetConnMaxLifetime(5 * time.Minute) // 连接最大生命周期
}

package main

import (
    "database/sql"
    "fmt"
    "log"
    "os"
    "strconv"
    "time"

    _ "github.com/lib/pq" // PostgreSQL driver
    // _ "github.com/go-sql-driver/mysql" // MySQL driver
)

const C_CONN_RDBMS = "postgres"
const C_CONN_STR = "user=admin dbname=testdb password=admin sslmode=disable"
// const C_CONN_RDBMS = "mysql"
// const C_CONN_STR = "user:password@tcp(127.0.0.1:3306)/testdb?charset=utf8"

var dbConn *sql.DB // Db connection pool

func main() {
    fmt.Println("\ntestdb1 - small test on " + C_CONN_RDBMS + " driver")

    // 1. 初始化数据库连接池 (只执行一次)
    var err error
    dbConn, err = sql.Open(C_CONN_RDBMS, C_CONN_STR)
    if err != nil {
        log.Fatalf("Failed to open Db Connection. Error = %s\n", err)
    }
    defer func() {
        if err := dbConn.Close(); err != nil {
            log.Printf("Error closing DB connection: %v", err)
        }
    }()

    // 可选：配置连接池参数
    dbConn.SetMaxOpenConns(25) // 根据实际负载调整
    dbConn.SetMaxIdleConns(10) // 保持一定数量的空闲连接
    dbConn.SetConnMaxLifetime(5 * time.Minute) // 连接最长生命周期

    println()
    iIters := fGetIterations()

    tmeStart := time.Now()

    fDbTestInserts(iIters) // run test Insert

    fmt.Printf("Elapsed Time to process = %s\n", time.Since(tmeStart))
}

func fDbTestInserts(iIters int) {
    var iCommitted int = 0
    println("Running test inserts .........")

    for iPos := 1; iPos <= iIters; iPos += 1 {
        // 1. 开始事务
        tx, err := dbConn.Begin()
        if err != nil {
            fmt.Printf("Begin Transaction failed. Error = %s\n", err)
            return
        }

        // 2. 立即使用 defer 确保事务被回滚或提交后连接被释放
        // 如果事务成功提交，Rollback() 会返回 sql.ErrTxDone，表示事务已完成，无需再次回滚。
        // 如果发生错误，Rollback() 会执行实际的回滚操作。
        defer func() {
            if rerr := tx.Rollback(); rerr != nil && rerr != sql.ErrTxDone {
                log.Printf("Rollback failed: %v", rerr)
            }
        }()

        // 3. 在事务中执行 SQL 语句
        sSql := "INSERT INTO test01 (sName, dBalance) VALUES ($1, $2)" // PostgreSQL 占位符
        // 对于 MySQL, 占位符通常是 ?
        // sSql := "INSERT INTO test01 (sName, dBalance) VALUES (?, ?)"

        _, err = tx.Exec(sSql, "Bart Simpson", 999.99)
        if err != nil {
            fmt.Printf("INSERT for Table failed. Error = %s\n", err)
            // defer 会处理回滚
            return
        }

        // 4. 提交事务
        err = tx.Commit() // 正确的提交方式
        if err != nil {
            fmt.Printf("COMMIT for Insert failed. Error = %s\n", err)
            // 提交失败，defer 的 Rollback 不会被执行（因为Commit会关闭事务），但这里应处理Commit本身的错误
            return
        }
        iCommitted += 1

        if iPos%100 == 0 {
            fmt.Printf("Iteration = %d, Inserted = %d   \n", iPos, iCommitted)
        }
    }

    fmt.Printf("Inserts completed - committed = %d\n", iCommitted)
}

// fGetIterations 和 fGetCloseConn 保持不变，但 fGetCloseConn 的逻辑在修正后的代码中不再使用。
func fGetIterations() int {
    // ... (代码与原问题相同)
    var sInput string
    fmt.Print("Number of Inserts to process : (1 to 10,000) or 'end' : ")
    _, err := fmt.Scanln(&sInput)
    if err != nil && err.Error() != "unexpected newline" { // 忽略空行
        log.Printf("Scan error: %v", err)
    }

    for {
        if sInput == "end" || sInput == "END" {
            os.Exit(1)
        }
        iTot, oError := strconv.Atoi(sInput)
        if oError != nil {
            println("Invalid number")
        } else if iTot < 1 || iTot > 10000 {
            println("Number must be from 1 to 10,000")
        } else {
            return iTot
        }
        fmt.Print("Number of Inserts to process : (1 to 10,000) or 'end' : ")
        _, err = fmt.Scanln(&sInput)
        if err != nil && err.Error() != "unexpected newline" {
            log.Printf("Scan error: %v", err)
        }
    }
}