Bagaimana untuk melakukan operasi pangkalan data tak segerak di Golang?

Terdapat dua cara utama untuk melaksanakan operasi pangkalan data tak segerak di Golang: menggunakan coroutine: melaksanakan pertanyaan secara tidak segerak dalam urutan latar belakang. Jika pertanyaan dibatalkan, program mencetak mesej "Pertanyaan dibatalkan". Gunakan kumpulan goroutine: Untuk aplikasi yang mengendalikan sejumlah besar pertanyaan selari, kumpulan goroutine boleh meningkatkan prestasi kerana ia boleh menggunakan semula coroutine untuk melaksanakan tugas.

Operasi Pangkalan Data Tak Segerak di Golang

Operasi pangkalan data tak segerak membolehkan aplikasi terus melaksanakan tugas lain sementara menunggu keputusan pertanyaan. Ini boleh meningkatkan prestasi aplikasi, terutamanya untuk aplikasi yang melibatkan I/O pangkalan data yang berat.

Menggunakan Coroutines

Cara biasa untuk melaksanakan operasi pangkalan data tak segerak di Golang ialah menggunakan coroutine (goroutine). Coroutine ialah utas ringan yang dijalankan serentak dan boleh dijalankan pada masa yang sama dengan utas utama.

Contoh kod berikut menunjukkan cara menggunakan coroutine untuk melaksanakan pertanyaan pangkalan data secara tak segerak:

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

Kod ini akan melaksanakan pertanyaan pangkalan data secara tak segerak dalam coroutine latar belakang. Jika pertanyaan dibatalkan sebelum ia selesai, kod tersebut mencetak mesej "Pertanyaan dibatalkan".

Gunakan kolam goroutine

Untuk aplikasi yang perlu mengendalikan sejumlah besar pertanyaan pangkalan data selari, menggunakan kolam goroutine boleh meningkatkan prestasi. Kolam goroutine ialah set goroutin terurus yang boleh digunakan semula untuk melaksanakan tugas.

Contoh kod berikut menunjukkan cara menggunakan kolam goroutine untuk operasi pangkalan data tak segerak:

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

Kod ini serupa dengan contoh sebelumnya, tetapi ia menggunakan kolam goroutine untuk mengurus coroutine. Ini mengurangkan overhed untuk mencipta coroutine baharu, dengan itu meningkatkan prestasi.

Atas ialah kandungan terperinci Bagaimana untuk melakukan operasi pangkalan data tak segerak di Golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!