Programação simultânea com go-mssqldb

As aplicações Go usam frequentemente goroutines para lidar com tarefas concorrentes. O go-mssqldb driver e o database/sql pacote foram concebidos para uso simultâneo, mas deve seguir padrões específicos para evitar fugas de ligação, corridas de dados e falta de pool. Este artigo aborda a segurança das rotinas, piscinas de trabalhadores e padrões de desligamento elegantes.

Segurança das goroutines

SQL. O DB é seguro para uso simultâneo

Uma *sql.DB instância é segura para usar a partir de várias goroutines simultaneamente. Gere um pool interno de ligações e gere a sincronização:

// 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

Não crie uma nova sql.Open por solicitação ou por goroutine. Cada sql.Open chamada cria um conjunto de ligações separado. Criar pools por pedido desperdiça recursos e pode esgotar rapidamente os limites de ligação do lado do servidor.

sql.Rows, sql.Tx e sql.Conn não são seguros para utilização concorrente

Estes tipos representam uma única ligação e devem ser usados a partir de uma goroutine de cada vez:

// 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.
}

Padrão de conjunto de trabalhadores

Quando precisar de processar muitos itens em simultâneo (por exemplo, atualizar milhares de registos), utilize um grupo de trabalhadores de tamanho fixo. Esta abordagem limita a concorrência para evitar o esgotamento do pool e a sobrecarga do servidor:

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
}

Use o errgroup para pools de trabalhadores

O golang.org/x/sync/errgroup pacote simplifica os grupos de trabalhadores com propagação de erros e cancelamento de contexto incorporados:

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

Defina o limite errgroup para um valor inferior a MaxOpenConns. Se o número de trabalhadores for igual ao tamanho do grupo, os trabalhadores consomem todas as ligações e não deixam espaço para exames de saúde ou outras questões.

Consultas paralelas

Execute consultas independentes em simultâneo para reduzir a latência total:

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
}

Processamento em lote com concorrência controlada

Para operações em grandes lotes (importação de dados, sincronização de registos), combine lote com concorrência para maximizar o rendimento:

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()
}

Desligamento gracioso

Quando a sua aplicação receber um sinal de encerramento, esgote as operações ativas da base de dados antes de fechar o pool. Chamar db.Close() de forma abrupta cancela consultas em curso e pode deixar o servidor com sessões órfãs.

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.")
}

Importante

Fecha o pool da base de dados depois de o teu servidor HTTP (ou outro router de pedidos) terminar de descarregar. Se fechares primeiro o pool, os handlers em execução recebem erros de ligação interrompida.

Dimensionamento do pool de ligações para cargas de trabalho concorrentes

Dimensione o pool de ligações com base na concorrência esperada da sua aplicação, não no número total de goroutines:

Tipo de aplicação	Recomendado MaxOpenConns	Fundamentação
API HTTP, baixa concorrência	10-25	Corresponde ao número típico de pedidos simultâneos.
API HTTP, alta concorrência	25-50	Mais ligações para manipuladores paralelos.
Trabalhador de fundo (lote)	5-10 por grupo de trabalhadores	Cada trabalhador precisa da sua própria ligação.
Misto (API + empregos em segundo plano)	Soma da API + necessidades de trabalhadores	Certifique-se de que cada subsistema tem margem de segurança suficiente.

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

Defina sempre MaxOpenConns. O padrão (0) é ilimitado. Um pool ilimitado sob carga pode abrir centenas de ligações e sobrecarregar o servidor, especialmente no SQL do Azure, onde os limites de ligação dependem do nível.

Evitar erros comuns de concorrência

Não partilhe *sql.Rows entre goroutines

Passar um *sql.Rows valor a múltiplas goroutines provoca corridas de dados:

// 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.

Não te esqueças de fechar as linhas em ciclos

A fuga *sql.Rows dentro de um circuito exaua a piscina de ligação:

// 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()
}

Não uses db.Conn, a menos que precises de afinidade de conexão

db.Conn(ctx) Fixa uma conexão específica. Se o usar desnecessariamente, reduz o tamanho efetivo da piscina:

// 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")

Lista de verificação de concorrência

Area	Recommendation
Partilha de piscinas	Crie uma *sql.DB instância para toda a aplicação.
Segurança das goroutines	Não partilhem *sql.Rows, *sql.Tx, nem *sql.Conn entre goroutines.
Grupos de trabalhadores	Utilize errgroup.SetLimit ou um canal de semáforo para controlar a concorrência.
Dimensionamento da piscina	Define MaxOpenConns abaixo do limite de ligação ao servidor.
Desligamento gracioso	Esgote os manipuladores HTTP antes de fechar o pool de ligações à base de dados.
Limpeza de recursos	Sempre defer rows.Close() e defer tx.Rollback() na goroutine que os criou.
Consultas paralelas	Execute consultas independentes em simultâneo para reduzir a latência das páginas de agregação.

Conteúdo relacionado

• Pool de conexões
• Tratamento de erros e padrões de repetição
• Transações
• Afinação de desempenho