In Go, how to correctly close database connections for multiple Goroutine shared?

Elegant close of Go multi-Goroutine shared database connection

In Go concurrent programming, how to safely close the connection is a critical issue when multiple Goroutines share database connections. Improper shutdown method can lead to data loss or program crash. This article will discuss several solutions and analyze their advantages and disadvantages.

Suppose we have a scenario: multiple Goroutines perform database query operations concurrently, sharing the same database connection.

Error demonstration: Use defer to close connection in main Goroutine

The following code demonstrates a common error:

 db := openDB()
defer db.Close() // Error: When the main Goroutine is closed, other Goroutines may still be using for i := 0; i <p> <code>defer db.Close()</code> will be executed at the end of the main Goroutine, but at this time other Goroutines may still be using the database connection, causing program crashes or data errors.</p><p> <strong>Error demonstration: Close connection in every Goroutine</strong></p><p> Putting <code>db.Close()</code> in every Goroutine is not the correct solution either:</p><pre class="brush:php;toolbar:false"> func queryDB(db *DB, i int) {
    defer db.Close() // Error: Every Goroutine tries to close the connection // ... database query operation...
}

This causes the connection to be closed multiple times, throwing an error.

Correct solution 1: Use WaitGroup to synchronize Goroutine

Using sync.WaitGroup ensures that all Goroutines have finished their work before closing the connection:

 var wg sync.WaitGroup
db := openDB()
defer db.Close() // Correct: Close for i := 0; i <p> This method counts Goroutines by <code>wg.Add(1)</code> and <code>wg.Done()</code> , and <code>wg.Wait()</code> blocks until all Goroutines are completed, ensuring that the connection is closed at a safe point in time.</p><p> <strong>Correct solution 2: Use global variables and main Goroutine control</strong></p><p> Another simpler way is to define the database connection as a global variable and manage it uniformly in the main Goroutine:</p><pre class="brush:php;toolbar:false"> var db *DB

func main() {
    db = openDB()
    defer db.Close() // Correct: Close uniformly in the main Goroutine // ... Start Goroutine ...
}

func queryDB(i int) {
    // ... Database query operation...
}

This way clearly centers the management of connections on the main Goroutine, avoiding concurrent access and closure issues.

Which solution to choose depends on the specific application scenario and code complexity. The WaitGroup method is suitable for more complex concurrent scenarios, while the global variable method is more concise and easy to understand in simple scenarios. The key is to make sure the database connection is closed only once and after all Goroutines have completed operations.

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