How to properly close database connections for multiple Goroutine shared in Go language?

Elegant close of Go multi-Goroutine shared database connection

In Go concurrent programming, multiple Goroutine shared database connections are common scenarios. Improper connection shutdown may result in data loss or program crash. This article explores how to safely close database connections for multiple Goroutine shared.

Problem analysis:

Using defer db.Close() directly in the main Goroutine cannot guarantee that all child Goroutines have completed database operations, which may cause the connection to be closed in advance and raise an error. Using defer db.Close() in each child Goroutine will cause the connection to be closed multiple times, and the same error will be raised.

Solution:

It is recommended to use counters and sync.WaitGroup to coordinate the execution of Goroutine and the closing of database connections.

Sample code:

 package main

import (
    "fmt"
    "sync"
    "time"

    "database/sql"
    _ "github.com/go-sql-driver/mysql" // Replace with your database driver)

type dbConn struct {
    conn *sql.DB
    wg *sync.WaitGroup
}

func openDb() (*dbConn, error) {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database") // Replace with your database connection string if err != nil {
        return nil, err
    }
    return &dbConn{conn: db, wg: &sync.WaitGroup{}}, nil
}

func (dc *dbConn) close() error {
    dc.wg.Wait() // Wait for all Goroutines to complete return dc.conn.Close()
}

func querydb(dc *dbConn, i int) {
    defer dc.wg.Done()
    dc.wg.Add(1) // Counter is added 1
    // ... Database operation...
    time.Sleep(time.Second) // Simulate database operations time-consuming fmt.Printf("Goroutine %d finished\n", i)
}

func main() {
    dc, err := openDb()
    if err != nil {
        fmt.Println("Error opening database:", err)
        Return
    }
    defer dc.close() // Make sure to close the connection last for i := 0; i <p> <strong>Code explanation:</strong></p><ol>
<li> The <code>dbConn</code> structure contains the database connection and <code>sync.WaitGroup</code> to manage the execution of Goroutines.</li>
<li> The <code>openDb</code> function opens the database connection and returns <code>dbConn</code> instance.</li>
<li> The <code>close</code> method uses <code>dc.wg.Wait()</code> to wait for all Goroutines to complete before closing the database connection.</li>
<li> <code>querydb</code> function uses <code>dc.wg.Add(1)</code> to increase the counter before executing the database operation, and uses <code>defer dc.wg.Done()</code> to decrease the counter after the operation is completed.</li>
<li> <code>main</code> function starts multiple Goroutines to execute <code>querydb</code> functions, and finally closes the database connection using <code>defer dc.close()</code> .</li>
</ol><p> This method ensures that all Goroutines complete database operations and then close the database connection, avoiding data loss and errors. Remember to replace the database connection string and driver in the sample code. If the database operation time is unpredictable, more complex mechanisms may be required to wait for all Goroutines to complete, such as signaling using a channel.</p>

The above is the detailed content of How to properly close database connections for multiple Goroutine shared in Go language?. For more information, please follow other related articles on the PHP Chinese website!