Coroutines Golang et programmation système de type Unix

La coroutine Golang est un mécanisme d'exécution simultanée créé via le mot-clé goroutine et utilisé pour la programmation système de type Unix. Il implémente la communication inter-coroutines via des canaux et peut être utilisé sur des serveurs Web simultanés pour améliorer les performances et l'évolutivité dans la pratique.

Coroutines Golang et programmation système de type Unix

Introduction

Les coroutines sont un mécanisme d'exécution simultané léger qui peut considérablement améliorer les performances des applications, en particulier lorsqu'il s'agit de tâches à forte concurrence et à forte intensité d'E/S pendant la tâche. Le langage Golang fournit un puissant support de coroutine, ce qui le rend idéal pour programmer des systèmes de type Unix.

Création et gestion de coroutines

Dans Golang, vous pouvez utiliser le mot-clé goroutine pour créer une coroutine : goroutine 关键字创建协程：

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        fmt.Println("这是另一个协程！")
    }()
    runtime.Gosched() // 主动让出 CPU 给其他协程
}

上述代码创建了一个协程，该协程在 main 函数之外执行，并打印一条消息。runtime.Gosched()

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个有缓冲的通道，存放整数
    ch := make(chan int, 10)

    // 在一个协程中向通道发送数据
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
            time.Sleep(100 * time.Millisecond) // 延迟发送数据
        }
        close(ch) // 关闭通道，表示不再发送数据
    }()

    // 在另一个协程中从通道读取数据
    go func() {
        for {
            v, ok := <-ch
            if !ok {
                break // 通道已关闭
            }
            fmt.Println(v)
        }
    }()

    time.Sleep(1100 * time.Millisecond) // 等待协程执行完毕
}

Le code ci-dessus crée une coroutine, qui se trouve dans main</ code> est exécuté en dehors de la fonction et imprime un message. La fonction <code>runtime.Gosched() libère activement les ressources CPU et permet à d'autres coroutines de s'exécuter.

Channel Communication

Channel est le mécanisme utilisé pour la communication inter-coroutine dans Golang. Il s'agit d'une méthode de communication de type sécurisé et non bloquant :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!\n")
    })

    // 使用 Goroutine 同时监听多个端口
    go http.ListenAndServe(":8080", nil)
    go http.ListenAndServe(":8081", nil)

    select {} // 阻塞主协程，保持服务器运行
}

Exemple pratique : serveur Web simultané

Prenons l'exemple d'un serveur Web simultané qui gère les requêtes des clients :

rrreee

En utilisant des coroutines, ce serveur peut traiter les requêtes sur plusieurs ports simultanément, améliorant ainsi l'évolutivité et les performances. 🎜

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!