Coroutine Golang dan async/menunggu

Coroutines dan async/wait in Go ialah primitif serentak Coroutines ialah urutan pelaksanaan yang ringan dan async/wait ialah gula sintaksis, membenarkan penulisan kod tak segerak. Coroutine dijalankan dalam goroutine dan dibuat menggunakan kata kunci go. async/wait menggunakan kata kunci async untuk mentakrifkan coroutine dan menggunakan kata kunci await untuk menjeda coroutine semasa dan menunggu coroutine lain selesai. Dalam amalan, coroutine boleh digunakan untuk mengurus permintaan serentak dan mengelakkan overhed mencipta dan memusnahkan coroutine untuk setiap permintaan melalui kumpulan goroutine.

Perbandingan coroutine dan async/tunggu dalam Go

Dalam Go, coroutine dan async/tunggu ialah dua primitif serentak yang digunakan untuk menulis kod serentak.

Coroutines

Coroutines ialah urutan pelaksanaan ringan yang membolehkan kami melaksanakan kod di berbilang tempat pada masa yang sama. Coroutine dijalankan dalam goroutine, iaitu pelaksanaan bahasa Go bagi urutan mod pengguna.

Berikut ialah contoh kod untuk mencipta dan menggunakan coroutine:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Println(i)
            wg.Done()
        }(i)
    }

    wg.Wait()
}

async/wait

async/wait ialah gula sintaktik yang membolehkan kita menulis kod tak segerak seolah-olah ia dilaksanakan dalam kod segerak. Kata kunci async digunakan untuk menentukan coroutine, manakala kata kunci tunggu digunakan untuk menjeda coroutine semasa dan menunggu coroutine lain selesai.

Berikut ialah contoh kod mencipta dan menggunakan async/menunggu:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    wg.Add(1)
    result := asyncFunc()

    fmt.Println(result)

    wg.Wait()
}

func asyncFunc() int {
    return 42
}

Kes praktikal

Kita boleh menggunakan coroutine dan async/menunggu untuk menyelesaikan pelbagai masalah konkurensi. Salah satu kegunaan yang paling biasa adalah untuk mengurus permintaan serentak melalui penggunaan kolam goroutine.

Berikut ialah contoh kod Go yang menggunakan kumpulan goroutine untuk mengendalikan permintaan HTTP:

package main

import (
    "fmt"
    "net/http"
    "sync"
)

var pool = sync.Pool{
    New: func() interface{} {
        return new(http.Request)
    },
}

func handler(w http.ResponseWriter, r *http.Request) {
    // 从池中检索请求
    req := pool.Get().(*http.Request)
    *req = *r

    // 处理请求

    // 将请求放回池中
    pool.Put(req)
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Dengan menggunakan kumpulan coroutine, kami mengelakkan overhed mencipta dan memusnahkan coroutine untuk setiap permintaan. Ini boleh meningkatkan prestasi pengendalian permintaan serentak dengan ketara.

Atas ialah kandungan terperinci Coroutine Golang dan async/menunggu. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!