Pratique de programmation asynchrone de la fonction Golang

La programmation asynchrone permet d'effectuer des tâches sans bloquer le thread principal. Le langage Go utilise une goroutine de thread légère et un canal de communication pour implémenter la programmation asynchrone. Les goroutines sont créées avec le mot-clé go et les canaux sont utilisés pour envoyer et recevoir des données entre les goroutines. Cas pratique : les requêtes Web simultanées utilisent un canal pour recevoir des réponses aux requêtes et envoyer simultanément des requêtes HTTP GET via goroutine. Le thread principal reçoit la réponse du canal et imprime les résultats, améliorant ainsi les performances et la réactivité du programme.

Pratique de programmation asynchrone pour les fonctions du langage Go

La programmation asynchrone est une technique de programmation parallèle qui permet aux programmeurs d'effectuer plusieurs tâches sans bloquer le thread principal. Dans le langage Go, la programmation asynchrone peut être facilement implémentée à l'aide de goroutine et channel. goroutine 和 channel 可以轻松地实现异步编程。

Goroutine

Goroutine 是 Go 语言中的轻量级线程。与传统线程不同，goroutine 非常轻量，并且由 Go 运行时管理。使用 go

Goroutine

Goroutine est un fil de discussion léger en langage Go. Contrairement aux threads traditionnels, les goroutines sont très légères et gérées par le runtime Go. Les goroutines peuvent être créées à l'aide du mot-clé go.

go func() {
  // 异步任务
}

channel

channel est le pipeline utilisé par le langage Go pour communiquer entre les goroutines. Les canaux peuvent être utilisés pour envoyer et recevoir des données.

ch := make(chan int)  // 创建一个无缓冲 channel

// 向 channel 发送数据
ch <- 42

// 从 channel 接收数据
x := <-ch

Cas pratique : requêtes Web simultanées

Ce qui suit est un cas pratique de requêtes Web simultanées asynchrones : 🎜

package main

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

func main() {
  // 创建一个 channel 来接收请求响应
  results := make(chan string)

  // 发送并发请求
  for i := 0; i < 10; i++ {
    go func(i int) {
      // 发送 HTTP GET 请求
      resp, err := http.Get(fmt.Sprintf("https://example.com/%d", i))
      if err != nil {
        results <- fmt.Sprintf("Error: %v", err)
        return
      }

      // 接收响应并发送结果
      body, err := ioutil.ReadAll(resp.Body)
      if err != nil {
        results <- fmt.Sprintf("Error: %v", err)
        return
      }

      results <- fmt.Sprintf("Response: %s", string(body))
    }(i)
  }

  // 接收并发请求的响应
  for j := 0; j < 10; j++ {
    fmt.Println(<-results)
  }
}

🎜Ce programme crée un canal pour recevoir les réponses aux requêtes, puis démarre 10 goroutines pour envoyer simultanément des requêtes HTTP GET. Chaque goroutine envoie le résultat au canal après avoir reçu la réponse. Le thread principal reçoit les résultats du canal et les imprime sur la console. 🎜🎜Grâce à la programmation asynchrone, ce programme peut gérer les requêtes simultanément sans bloquer le thread principal, améliorant ainsi les performances et la réactivité de l'application. 🎜

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!