Comment effectuer des opérations de base de données asynchrones dans Golang ?

Il existe deux manières principales d'effectuer des opérations de base de données asynchrones dans Golang : en utilisant des coroutines : exécuter des requêtes de manière asynchrone dans les threads d'arrière-plan. Si la requête est annulée, le programme imprime le message "Requête annulée". Utilisez un pool goroutine : pour les applications qui gèrent un grand nombre de requêtes parallèles, un pool goroutine peut améliorer les performances car il réutilise les coroutines pour effectuer des tâches.

Opérations de base de données asynchrones dans Golang

Les opérations de base de données asynchrones permettent aux applications de continuer à effectuer d'autres tâches en attendant les résultats de la requête. Cela peut grandement améliorer les performances des applications, en particulier pour les applications impliquant de lourdes E/S de base de données.

Utilisation de coroutines

Une façon courante d'effectuer des opérations de base de données asynchrones dans Golang consiste à utiliser des coroutines (goroutine). Les coroutines sont des threads légers qui s'exécutent simultanément et peuvent s'exécuter en même temps que le thread principal.

L'exemple de code suivant montre comment utiliser une coroutine pour exécuter de manière asynchrone une requête de base de données :

package main

import (
    "context"
    "database/sql"
    "fmt"
    "time"
)

func main() {
    // 打开数据库连接
    db, err := sql.Open("postgres", "user=postgres password=my-password database=database host=localhost port=5432")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    // 创建用于取消查询的上下文
    ctx := context.Background()

    // 创建协程
    go func() {
        // 使用 ctx.Done() 检查是否已取消查询
        for {
            select {
            case <-ctx.Done():
                fmt.Println("查询已取消")
                return
            default:
                // 执行查询
                rows, err := db.QueryContext(ctx, "SELECT name FROM people")
                if err != nil {
                    fmt.Println(err)
                    continue
                }

                // 迭代查询结果
                for rows.Next() {
                    var name string
                    if err := rows.Scan(&name); err != nil {
                        fmt.Println(err)
                        continue
                    }
                    fmt.Println(name)
                }
                rows.Close()
            }
        }
    }()

    // 等待一段时间，然后取消查询
    time.Sleep(time.Second * 2)
    ctx.Cancel()
}

Ce code exécutera de manière asynchrone une requête de base de données dans une coroutine en arrière-plan. Si la requête est annulée avant d'être terminée, le code imprime le message « Requête annulée ».

Utiliser le pool goroutine

Pour les applications qui doivent gérer un grand nombre de requêtes de bases de données parallèles, l'utilisation du pool goroutine peut améliorer les performances. Un pool de goroutines est un ensemble géré de goroutines qui peuvent être réutilisées pour effectuer des tâches.

L'exemple de code suivant montre comment utiliser un pool de goroutines pour les opérations de base de données asynchrones :

package main

import (
    "context"
    "database/sql"
    "fmt"
    "sync"
    "time"
)

func main() {
    // 创建 goroutine pool
    pool := sync.Pool{
        New: func() interface{} {
            return &sql.DB{}
        },
    }

    // 打开数据库连接
    db := pool.Get().(*sql.DB)
    defer pool.Put(db)

    // 创建用于取消查询的上下文
    ctx := context.Background()

    // 创建 goroutine
    go func() {
        // 使用 ctx.Done() 检查是否已取消查询
        for {
            select {
            case <-ctx.Done():
                fmt.Println("查询已取消")
                return
            default:
                // 执行查询
                rows, err := db.QueryContext(ctx, "SELECT name FROM people")
                if err != nil {
                    fmt.Println(err)
                    continue
                }

                // 迭代查询结果
                for rows.Next() {
                    var name string
                    if err := rows.Scan(&name); err != nil {
                        fmt.Println(err)
                        continue
                    }
                    fmt.Println(name)
                }
                rows.Close()
            }
        }
    }()

    // 等待一段时间，然后取消查询
    time.Sleep(time.Second * 2)
    ctx.Cancel()
}

Ce code est similaire à l'exemple précédent, mais il utilise un pool de goroutines pour gérer les coroutines. Cela réduit la surcharge liée à la création de nouvelles coroutines, améliorant ainsi les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!