Optez pour la programmation concurrente : programmation asynchrone et IO non bloquantes

En Go, la programmation asynchrone et les E/S non bloquantes sont disponibles pour la programmation simultanée. La programmation asynchrone utilise des Goroutines légers pour effectuer des tâches en arrière-plan pendant que le programme principal poursuit son exécution. Les E/S non bloquantes utilisent l'interface io.Reader pour effectuer des opérations d'entrée/sortie sans attendre la fin. Ces deux concepts peuvent être utilisés dans des applications réelles telles que le traitement efficace des requêtes Web.

Programmation parallèle Go : programmation asynchrone et IO non bloquantes

En langage Go, la programmation asynchrone et les IO non bloquantes sont des concepts clés de la programmation simultanée. Cet article approfondira les deux concepts et démontrera leur application dans le monde réel à travers des exemples pratiques.

Programmation asynchrone

La programmation asynchrone est un style de programmation dans lequel les événements sont traités au fur et à mesure qu'ils se produisent plutôt que d'attendre qu'ils se terminent. Dans le langage Go, la programmation asynchrone est principalement implémentée via Goroutine. Goroutine est un thread léger dans le langage Go qui peut exécuter des tâches simultanément en arrière-plan.

func main() {
    ch := make(chan string)

    // 启动一个Goroutine
    go func() {
        time.Sleep(1 * time.Second)
        ch <- "Hello, world!"
    }()

    // 主程序从通道中读取数据。如果数据尚未准备好，该行代码将阻塞
    result := <-ch
    fmt.Println(result) // 输出："Hello, world!"
}

Dans l'exemple ci-dessus, le programme principal démarre une Goroutine, qui traite une tâche en arrière-plan. Le programme principal n'a pas besoin d'attendre la fin de Goroutine avant de poursuivre son exécution, période pendant laquelle il peut effectuer d'autres tâches.

E/S non bloquantes

E/S non bloquantes est une opération d'entrée/sortie qui ne bloque pas l'exécution du programme jusqu'à ce que l'opération soit terminée. Dans le langage Go, les E/S non bloquantes sont généralement implémentées à l'aide de l'interface io.Reader. io.Reader接口来实现。

import (
    "bytes"
    "io"
    "log"
)

func main() {
    // 创建一个Buffer作为io.Reader
    reader := bytes.NewBufferString("Hello, world!")

    // 创建一个缓冲区并从reader中读取数据
    buf := make([]byte, 1024)
    n, err := reader.Read(buf)
    if err != nil {
        log.Fatal(err)
    }

    // 将读取到的数据转换成字符串
    result := string(buf[:n])
    fmt.Println(result) // 输出："Hello, world!"
}

在上面示例中，我们使用io.Reader

import (
    "fmt"
    "log"
    "net/http"

    // 导入第三方包
    "github.com/gorilla/mux"
)

func main() {
    // 创建一个mux路由器
    router := mux.NewRouter()

    // 使用Goroutine处理请求
    router.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(1 * time.Second)
        fmt.Fprintf(w, "Hello, world!")
    })

    // 监听端口
    log.Fatal(http.ListenAndServe(":8080", router))
}

Dans l'exemple ci-dessus, nous utilisons l'interface io.Reader pour lire les données d'un Buffer. Les opérations de lecture ne sont pas bloquantes, ce qui signifie que le programme principal ne se bloquera pas même si les données ne sont pas encore prêtes.

Cas pratiques

La programmation asynchrone et les E/S non bloquantes sont largement utilisées dans le développement d'applications. Un cas d’utilisation courant est la gestion des requêtes Web.

rrreee

Dans cet exemple, nous avons créé un routeur Web à l'aide de la bibliothèque tierce Gorilla Mux. Nous utilisons Goroutine pour gérer les requêtes HTTP afin que le programme principal puisse gérer plusieurs requêtes en même temps.

Conclusion

La programmation asynchrone et les E/S non bloquantes sont deux concepts importants dans la programmation concurrente en langage Go. En les utilisant ensemble, nous pouvons créer des applications réactives et performantes. 🎜

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!