requête asynchrone golang

Avec le développement rapide d'Internet, de plus en plus d'applications doivent interagir avec des services externes, et les API fournies par ces services sont souvent asynchrones. Dans les programmes monothread, les demandes de synchronisation provoquent souvent une congestion du programme, affectant les performances du programme et la vitesse de réponse. Par conséquent, en termes de requêtes asynchrones, la conception unique du langage golang nous permet d'implémenter plus facilement des appels asynchrones et d'améliorer le débit et la vitesse de réponse de l'application.

Cet article présentera comment Golang implémente les requêtes asynchrones, comprendra la goroutine et le canal dans Golang et comment les utiliser pour implémenter des opérations asynchrones.

goroutine

goroutine dans golang est un thread léger qui peut exécuter plusieurs tâches simultanément dans un seul thread. En utilisant le mot-clé go, nous pouvons démarrer une nouvelle goroutine dans le programme. Prenons un exemple simple :

go func() {
    fmt.Println("Hello, goroutine!")
}()

Dans l'exemple ci-dessus, nous démarrons une nouvelle goroutine et imprimons un message dans la goroutine. Lorsque nous exécutons le programme, nous pouvons voir que le message est imprimé avant le message du fil de discussion principal. Cela montre qu'il est exécuté dans différentes goroutines.

L'exécution de la routine goroutine démarrera lorsque l'instruction go sera appelée, et non lorsque la fonction démarrera. Par conséquent, nous pouvons démarrer plusieurs goroutines dans le même thread et exécuter plusieurs tâches simultanément sans nous soucier des conditions de concurrence entre elles.

channel

channel est un autre concept important dans Golang. Il s'agit d'un mécanisme de communication utilisé pour la transmission de données entre différentes goroutines. La méthode de création d'un canal est très simple :

ch := make(chan <type>)

où, <type> est le type de données transmis dans le canal. Lors de l'utilisation de canaux, nous pouvons utiliser le mot-clé <- pour envoyer ou recevoir des messages. Par exemple : <type> 是 channel 中传输的数据类型。在使用 channel 时，我们可以使用关键字 <- 来发送或接收消息。例如：

ch <- "Hello, channel!"
msg := <- ch

在上面的例子中，我们首先向 channel 中发送了一条消息，然后从该 channel 中接收该消息。同样，我们也可以在一个 goroutine 中发送消息，然后在另一个 goroutine 中接收该消息，从而实现不同 goroutine 间的通信。

异步请求

有了前面介绍的 goroutine 和 channel 的知识，我们现在可以轻松地实现异步请求了。例如，我们可以写一个函数，使用 goroutine 启动异步操作，并在操作完成后将结果发送到 channel 中。例如：

func asyncRequest(url string, ch chan<- []byte) {
    resp, err := http.Get(url)
    if err == nil {
        body, _ := ioutil.ReadAll(resp.Body)
        ch <- body
    }
}

在上面的函数中，我们首先使用 http.Get() 函数获取指定 URL 的响应。然后，如果没有出现错误，我们会将响应的主体发送到 channel 中。注意，我们在函数签名中使用了 ch chan<- []byte，这表示该 channel 只能用于发送数据，而不能用于接收数据。

现在，我们可以使用该函数来启动异步请求，并在请求完成后接收响应。例如：

func main() {
    ch := make(chan []byte)
    go asyncRequest("https://www.example.com", ch)
    data := <- ch
    fmt.Printf("Response: %s
", data)
}

在上面的例子中，我们启动了一个异步请求，并使用 <- chrrreee

Dans l'exemple ci-dessus, nous avons d'abord envoyé un message à la chaîne, puis avons reçu le message de la chaîne. De même, nous pouvons également envoyer un message dans une goroutine puis recevoir le message dans une autre goroutine pour établir la communication entre différentes goroutines.

Requêtes asynchrones🎜🎜Avec la connaissance de goroutine et de canal introduite précédemment, nous pouvons désormais facilement implémenter des requêtes asynchrones. Par exemple, nous pouvons écrire une fonction qui utilise une goroutine pour démarrer une opération asynchrone et envoyer le résultat à un canal lorsque l'opération est terminée. Par exemple : 🎜rrreee🎜Dans la fonction ci-dessus, nous utilisons d'abord la fonction http.Get() pour obtenir la réponse de l'URL spécifiée. Ensuite, si aucune erreur ne se produit, nous envoyons le corps de la réponse au canal. Notez que nous avons utilisé ch chan<- []byte dans la signature de la fonction, ce qui signifie que le canal ne peut être utilisé que pour envoyer des données, pas pour recevoir des données. 🎜🎜Nous pouvons désormais utiliser cette fonction pour lancer une requête asynchrone et recevoir la réponse une fois la requête terminée. Par exemple : 🎜rrreee🎜Dans l'exemple ci-dessus, nous lançons une requête asynchrone et recevons la réponse du canal en utilisant la syntaxe <- ch. Une fois l'opération asynchrone terminée, nous recevons une réponse et imprimons son corps. 🎜🎜En utilisant la méthode ci-dessus, nous pouvons facilement implémenter des requêtes asynchrones sans nous soucier des conditions de concurrence ou des programmes bloqués. De plus, les goroutines et les canaux de Golang peuvent facilement étendre nos applications pour implémenter des opérations asynchrones plus complexes. 🎜

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!