Le mécanisme de travail collaboratif des coroutines Go et des fonctions Golang

Les coroutines et les fonctions fonctionnent ensemble : Créez une coroutine : utilisez le mot-clé go pour créer une coroutine. Tâches parallèles : les tâches parallèles sont traitées via des coroutines. Collaboration fonctionnelle : les fonctions Coroutines et Golang fonctionnent ensemble pour implémenter des tâches simultanées plus complexes, telles que les téléchargements de fichiers parallèles. Applications pratiques : les coroutines sont largement utilisées dans des scénarios tels que les E/S parallèles, les serveurs Web, la concurrence d'algorithmes et les systèmes distribués.

Le mécanisme de travail collaboratif des coroutines Go et des fonctions Golang

Introduction

Les coroutines Go sont un modèle de concurrence léger qui permet aux développeurs de créer et de gérer plusieurs processus dans le même thread. Fonctions qui s'exécutent en parallèle. Les coroutines sont utiles dans de nombreux scénarios, tels que le traitement de tâches parallèles, la mise en œuvre d'opérations d'E/S simultanées ou le traitement de requêtes en parallèle sur un serveur Web.

Création de coroutines

Les coroutines peuvent être créées via le mot-clé go. Par exemple, le code suivant crée une coroutine pour imprimer « hello world » :

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        fmt.Println("hello world")
    }()

    time.Sleep(1 * time.Second)
}

Coopération des fonctions Golang et des coroutines

Les coroutines Go et les fonctions Golang peuvent travailler ensemble pour implémenter des tâches simultanées plus complexes. Par exemple, le code suivant utilise des coroutines pour implémenter des téléchargements de fichiers parallèles :

package main

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

func main() {
    urls := []string{"https://example.com/file1", "https://example.com/file2"}

    for _, url := range urls {
        go func(url string) {
            resp, err := http.Get(url)
            if err != nil {
                log.Fatal(err)
            }
            defer resp.Body.Close()

            // 保存文件到本地磁盘
            out, err := os.Create(filepath.Base(url))
            if err != nil {
                log.Fatal(err)
            }
            defer out.Close()

            if _, err := io.Copy(out, resp.Body); err != nil {
                log.Fatal(err)
            }

            fmt.Printf("File downloaded: %s\n", filepath.Base(url))
        }(url)
    }

    // 主程序等待协程完成
    for {
        time.Sleep(1 * time.Second)
    }
}

Cas pratique

Les coroutines sont très utiles dans les applications pratiques. Voici quelques scénarios courants :

• Traitement des opérations d'E/S en parallèle
• Traitement parallèle des requêtes dans un serveur Web
• Implémentation d'algorithmes concurrents
• Écriture de systèmes distribués

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!