Coroutines Golang et async/wait

Les coroutines et async/await dans Go sont des primitives de concurrence. Les coroutines sont des threads d'exécution légers, et async/await est du sucre syntaxique, permettant l'écriture de code asynchrone. Les coroutines s'exécutent dans des goroutines et sont créées à l'aide du mot-clé go. async/await utilise le mot-clé async pour définir une coroutine et utilise le mot-clé wait pour suspendre la coroutine actuelle et attendre la fin des autres coroutines. En pratique, les coroutines peuvent être utilisées pour gérer les requêtes simultanées et éviter la surcharge liée à la création et à la destruction de coroutines pour chaque requête via le pool goroutine.

Comparaison des coroutines et async/await dans Go

Dans Go, les coroutines et async/await sont deux primitives de concurrence utilisées pour écrire du code simultané.

Coroutines

Les coroutines sont des threads d'exécution légers qui nous permettent d'exécuter du code à plusieurs endroits en même temps. Les coroutines s'exécutent dans goroutine, qui est l'implémentation des threads en mode utilisateur du langage Go.

Voici des exemples de code pour créer et utiliser des coroutines :

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/await

async/await est un sucre syntaxique qui nous permet d'écrire du code asynchrone comme s'il était exécuté en code synchrone. Le mot-clé async est utilisé pour définir une coroutine, tandis que le mot-clé wait est utilisé pour mettre en pause la coroutine en cours et attendre la fin d'une autre coroutine.

Ce qui suit est un exemple de code de création et d'utilisation de async/await :

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
}

Cas pratique

Nous pouvons utiliser des coroutines et async/await pour résoudre divers problèmes de concurrence. L'une des utilisations les plus courantes consiste à gérer les requêtes simultanées via l'utilisation de pools goroutines.

Voici un exemple de code Go qui utilise un pool de goroutines pour gérer les requêtes 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)
}

En utilisant un pool de coroutines, nous évitons la surcharge liée à la création et à la destruction de coroutines pour chaque requête. Cela peut améliorer considérablement les performances de traitement des demandes simultanées.

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!