Současné programování s go-mssqldb

Aplikace v jazyce Go běžně používají goroutines ke zpracování souběžných úloh. Ovladač go-mssqldb a balíček database/sql jsou navrženy pro souběžné použití, ale musíte dodržovat určité postupy, abyste předešli únikům připojení, kolizím při souběžném přístupu k datům a vyčerpání fondu připojení. Tento článek se zabývá bezpečností v režimu goroutine, pracovními skupinami a elegantními vzorci vypínání.

Bezpečnost gorutiny

sql.DB je bezpečný pro souběžné použití

Instanci *sql.DB lze bezpečně používat ve více gorutinách současně. Spravuje interní pool připojení a zajišťuje synchronizaci:

// CORRECT: Share a single *sql.DB across all goroutines.
var db *sql.DB

func main() {
    var err error
    db, err = sql.Open("sqlserver", connString)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    http.HandleFunc("/employees", listEmployees) // Each request runs in its own goroutine.
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Warning

Nevytvářejte nový sql.Open pro každý požadavek ani pro každou goroutinu. Každý sql.Open hovor vytváří samostatný pool spojení. Vytváření poolů na požadavek plýtvá zdroji a může rychle vyčerpat limity připojení na straně serveru.

sql.Rows, sql.Tx a sql.Conn nejsou bezpečné pro souběžné použití

Tyto typy představují jedno spojení a musí být použity vždy z jedné gorutiny:

// WRONG: Sharing rows across goroutines causes data races.
rows, _ := db.QueryContext(ctx, "SELECT BusinessEntityID, FirstName + ' ' + LastName FROM Sales.vSalesPerson")
go func() { rows.Next() }() // DATA RACE
go func() { rows.Next() }() // DATA RACE

// CORRECT: Process rows in the goroutine that created them.
rows, _ := db.QueryContext(ctx, "SELECT BusinessEntityID, FirstName + ' ' + LastName FROM Sales.vSalesPerson")
defer rows.Close()
for rows.Next() {
    // Process in this goroutine only.
}

Vzor pracovní skupiny

Když potřebujete zpracovávat více položek současně (například aktualizovat tisíce záznamů), použijte pevně velký pracovní pool. Tento přístup omezuje souběžnost, aby se zabránilo vyčerpání poolu a přetížení serveru:

import "sync"

func updateEmployeeLocations(ctx context.Context, db *sql.DB, updates []EmployeeUpdate) error {
    const maxWorkers = 10
    sem := make(chan struct{}, maxWorkers)
    var mu sync.Mutex
    var firstErr error

    var wg sync.WaitGroup
    for _, u := range updates {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case sem <- struct{}{}: // Acquire a worker slot.
        }

        wg.Add(1)
        go func(u EmployeeUpdate) {
            defer wg.Done()
            defer func() { <-sem }() // Release the worker slot.

            _, err := db.ExecContext(ctx,
                "UPDATE HumanResources.Department SET GroupName = @grp WHERE DepartmentID = @id",
                sql.Named("grp", u.GroupName),
                sql.Named("id", u.Id))
            if err != nil {
                mu.Lock()
                if firstErr == nil {
                    firstErr = err
                }
                mu.Unlock()
            }
        }(u)
    }

    wg.Wait()
    return firstErr
}

Použijte errgroup pro worker pooly

Balíček golang.org/x/sync/errgroup zjednodušuje pracovní pooly díky vestavěnému šíření chyb a rušení kontextu:

import "golang.org/x/sync/errgroup"

func updateDepartmentGroups(ctx context.Context, db *sql.DB, updates []DepartmentUpdate) error {
    g, ctx := errgroup.WithContext(ctx)
    g.SetLimit(10) // Maximum concurrent goroutines.

    for _, u := range updates {
        u := u
        g.Go(func() error {
            _, err := db.ExecContext(ctx,
                "UPDATE HumanResources.Department SET GroupName = @grp WHERE DepartmentID = @id",
                sql.Named("grp", u.GroupName),
                sql.Named("id", u.Id))
            return err
        })
    }

    return g.Wait()
}

Tip

Nastavte limit errgroup na hodnotu nižší než MaxOpenConns. Pokud počet pracovníků odpovídá velikosti poolu, pracovníci spotřebují všechna připojení a nenechávají prostor pro zdravotní prohlídky nebo jiné dotazy.

Paralelní dotazy

Spouštějte nezávislé dotazy současně, abyste snížili celkovou latenci:

func getDashboardData(ctx context.Context, db *sql.DB) (*Dashboard, error) {
    g, ctx := errgroup.WithContext(ctx)

    var orderCount int
    var customerCount int
    var revenue float64

    g.Go(func() error {
        return db.QueryRowContext(ctx,
            "SELECT COUNT(*) FROM Sales.SalesOrderHeader WHERE OrderDate >= DATEADD(day, -7, GETUTCDATE())").
            Scan(&orderCount)
    })

    g.Go(func() error {
        return db.QueryRowContext(ctx,
            "SELECT COUNT(DISTINCT CustomerID) FROM Sales.SalesOrderHeader WHERE OrderDate >= DATEADD(day, -7, GETUTCDATE())").
            Scan(&customerCount)
    })

    g.Go(func() error {
        return db.QueryRowContext(ctx,
            "SELECT ISNULL(SUM(TotalDue), 0) FROM Sales.SalesOrderHeader WHERE OrderDate >= DATEADD(day, -7, GETUTCDATE())").
            Scan(&revenue)
    })

    if err := g.Wait(); err != nil {
        return nil, err
    }

    return &Dashboard{
        OrderCount:    orderCount,
        CustomerCount: customerCount,
        WeeklyRevenue: revenue,
    }, nil
}

Dávkové zpracování s řízenou souběžností

Pro velké dávkové operace (import dat, synchronizace záznamů) kombinujte batch s souběžností pro maximalizaci propustnosti:

func importRecords(ctx context.Context, db *sql.DB, records []Record) error {
    const batchSize = 100
    const maxWorkers = 5

    g, ctx := errgroup.WithContext(ctx)
    g.SetLimit(maxWorkers)

    for i := 0; i < len(records); i += batchSize {
        end := i + batchSize
        if end > len(records) {
            end = len(records)
        }
        batch := records[i:end]

        g.Go(func() error {
            return insertBatch(ctx, db, batch)
        })
    }

    return g.Wait()
}

func insertBatch(ctx context.Context, db *sql.DB, batch []Record) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()

    stmt, err := tx.Prepare(mssql.CopyIn("Production.ScrapReason", mssql.BulkOptions{}, "Name"))
    if err != nil {
        return err
    }

    for _, r := range batch {
        if _, err := stmt.Exec(r.Name); err != nil {
            return err
        }
    }

    if _, err := stmt.Exec(); err != nil {
        return err
    }
    if err := stmt.Close(); err != nil {
        return err
    }

    return tx.Commit()
}

Bezpečné vypnutí

Když vaše aplikace obdrží signál vypnutí, vyprázdněte aktivní databázové operace před zavřením poolu. Náhlé volání db.Close() ruší dotazy během letu a může zanechat server s osiřelými sezeními.

import (
    "context"
    "database/sql"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    db, err := sql.Open("sqlserver", connString)
    if err != nil {
        log.Fatal(err)
    }

    srv := &http.Server{Addr: ":8080"}

    // Run the server in a goroutine.
    go func() {
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatalf("HTTP server error: %v", err)
        }
    }()

    // Wait for interrupt signal.
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    log.Println("Shutting down...")

    // Give in-flight HTTP requests up to 30 seconds to complete.
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := srv.Shutdown(shutdownCtx); err != nil {
        log.Printf("HTTP shutdown error: %v", err)
    }

    // Close the database pool after HTTP handlers have drained.
    // This waits for any remaining connections to be returned.
    if err := db.Close(); err != nil {
        log.Printf("Database close error: %v", err)
    }

    log.Println("Shutdown complete.")
}

Important

Databázový pool uzavřete poté, co váš HTTP server (nebo jiný router požadavků) dokončí vyčerpání. Pokud pool zavřete jako první, palubní handleři dostanou chyby s přerušeným připojením.

Dimenzování fondu připojení pro souběžná zatížení

Velikost poolu připojení nastavte podle očekávané souběžnosti vaší aplikace, nikoli podle celkového počtu goroutine:

Typ aplikace	Doporučené MaxOpenConns	Odůvodnění
HTTP API, nízká souběžnost	10-25	Odpovídá typickému počtu současných požadavků.
HTTP API, vysoká souběžnost	25-50	Více připojení pro paralelní handlery.
Pracovník pozadí (várka)	5-10 na skupinu pracovníků	Každý pracovník potřebuje své vlastní spojení.
Smíšené (API + úlohy na pozadí)	Součet potřeb API + pracovníků	Zajistěte, aby každý podsystém měl dostatek rezervy.

db.SetMaxOpenConns(25)    // Total connections across all goroutines.
db.SetMaxIdleConns(10)    // Keep warm connections ready for bursts.
db.SetConnMaxLifetime(5 * time.Minute) // Rotate connections for load balancer compatibility.

Tip

Vždy nastavte MaxOpenConns. Výchozí hodnota (0) je neomezená. Neomezený pool pod zátěží může otevřít stovky připojení a zahltit server, zejména na Azure SQL, kde jsou limity připojení závislé na jednotlivých úrovních.

Vyhněte se běžným chybám v souběžnosti

Nesdílejte *sql.Rows napříč gorutinami

Předání *sql.Rows hodnoty více gorutinám způsobuje datové závody:

// WRONG: rows is consumed by two goroutines.
rows, _ := db.QueryContext(ctx, "SELECT BusinessEntityID, FirstName + ' ' + LastName FROM Sales.vSalesPerson")
go processRows(rows)
go processRows(rows) // Race condition.

Nezapomeňte uzavřít řady ve smyčkách

Únik *sql.Rows uvnitř smyčky vyčerpává spojovací bazén:

// WRONG: Rows leak when the loop starts a new iteration.
for _, location := range locations {
    rows, _ := db.QueryContext(ctx,
        "SELECT FirstName + ' ' + LastName FROM Sales.vSalesPerson WHERE CountryRegionName = @p1",
        sql.Named("p1", location))
    for rows.Next() {
        // Process...
    }
    // rows.Close() never called if an error occurs.
}

// CORRECT: Use a helper function with defer.
for _, location := range locations {
    if err := processLocation(ctx, db, location); err != nil {
        return err
    }
}

func processLocation(ctx context.Context, db *sql.DB, location string) error {
    rows, err := db.QueryContext(ctx,
        "SELECT FirstName + ' ' + LastName FROM Sales.vSalesPerson WHERE CountryRegionName = @p1",
        sql.Named("p1", location))
    if err != nil {
        return err
    }
    defer rows.Close() // Guaranteed cleanup.
    for rows.Next() {
        // Process...
    }
    return rows.Err()
}

Nepoužívejte db.Conn, pokud nepotřebujete vazbu na konkrétní připojení.

db.Conn(ctx) připne konkrétní připojení. Pokud ho používáte zbytečně, snížíte efektivní velikost bazénu:

// WRONG: Unnecessary pinning.
conn, _ := db.Conn(ctx)
defer conn.Close()
conn.QueryContext(ctx, "SELECT 1") // Use db.QueryContext instead.

// CORRECT: Use db.Conn only for temp tables or session-scoped state.
conn, _ := db.Conn(ctx)
defer conn.Close()
conn.ExecContext(ctx, "CREATE TABLE #Temp (Id INT)")
conn.ExecContext(ctx, "INSERT INTO #Temp VALUES (1)")
conn.QueryContext(ctx, "SELECT * FROM #Temp")

Kontrolní seznam pro souběžnost

Area	Recommendation
Sdílení bazénu	Vytvořte jednu *sql.DB instanci pro celou aplikaci.
Bezpečnost gorutiny	Nesdílejte *sql.Rows, *sql.Tx ani *sql.Conn mezi goroutinami.
Pracovní skupiny	Použijte errgroup.SetLimit nebo semaforový kanál pro řízení souběžnosti.
Velikost bazénu	Nastavte MaxOpenConns nižší než limit připojení k serveru.
Bezpečné vypnutí	Vyčerpávejte HTTP handlery před uzavřením databázového poolu.
Vyčištění prostředků	Vždy používejte defer rows.Close() a defer tx.Rollback() v gorutině, která je vytvořila.
Paralelní dotazy	Spouštějte nezávislé dotazy současně, abyste snížili latenci u agregačních stránek.

Související obsah

• Sdružování připojení
• Zpracování chyb a vzory opakovaných pokusů
• Transakce
• Ladění výkonu