Résumé de l'expérience de programmation simultanée Golang : meilleures pratiques pour une application élégante de Goroutines

Résumé de l'expérience de programmation simultanée Golang : meilleures pratiques pour appliquer élégamment des Goroutines

Introduction :
À l'ère d'Internet hautement concurrente d'aujourd'hui, l'écriture de programmes parallèles efficaces est devenue de plus en plus importante. Golang, en tant que langage axé sur la programmation simultanée, fournit des outils puissants pour gérer un grand nombre de tâches simultanées. Les plus importants d'entre eux sont les Goroutines.

Les Goroutines sont le composant central du modèle de concurrence de Golang, qui nous permettent de créer des threads légers à très faible coût. En utilisant correctement Goroutines, nous pouvons écrire des programmes parallèles avec élégance et améliorer les performances et la fiabilité. Cet article résumera quelques bonnes pratiques pour appliquer avec élégance Goroutines afin d'aider les lecteurs à mieux maîtriser la programmation simultanée.

1. Concepts de base
Avant de commencer, passons en revue quelques concepts de base. Goroutine est un thread léger, et Golang gère et planifie ces Goroutines via l'exécution. Avec le mot-clé "go", on peut créer une nouvelle Goroutine dans le programme. Lorsque la tâche du Goroutine est terminée, elle se ferme automatiquement.

2. Comment utiliser Goroutines
Ce qui suit est un exemple simple montrant comment utiliser Goroutines pour télécharger plusieurs fichiers en même temps :

package main

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

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

    for _, url := range urls {
        go func(u string) {
            res, err := http.Get(u)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }
            defer res.Body.Close()

            content, err := ioutil.ReadAll(res.Body)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }

            fmt.Printf("Downloaded %s: %d bytes
", u, len(content))
        }(url)
    }

    // 在这里添加等待所有Goroutines完成的逻辑
    // ...

    fmt.Println("All downloads completed")
}

Dans le code ci-dessus, nous parcourons la liste des fichiers qui doivent être téléchargés via un for boucle, et dans chaque Une nouvelle Goroutine est créée à l'aide d'une fonction anonyme dans la deuxième boucle. Chaque Goroutine se charge de télécharger le fichier correspondant et d'imprimer les résultats du téléchargement.

3. Attendez que toutes les Goroutines soient terminées
Dans les applications pratiques, nous devons généralement attendre que toutes les Goroutines soient terminées avant d'effectuer d'autres opérations. Heureusement, Golang propose un moyen simple et efficace d'atteindre cet objectif, qui consiste à utiliser WaitGroup dans le package de synchronisation :

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
)

func main() {
    urls := []string{"https://example.com/file1.txt", "https://example.com/file2.txt", "https://example.com/file3.txt"}
    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1) // 每个Goroutine开始时增加WaitGroup的计数器

        go func(u string) {
            defer wg.Done() // Goroutine完成时减少WaitGroup的计数器

            res, err := http.Get(u)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }
            defer res.Body.Close()

            content, err := ioutil.ReadAll(res.Body)
            if err != nil {
                fmt.Println("Error:", err)
                return
            }

            fmt.Printf("Downloaded %s: %d bytes
", u, len(content))
        }(url)
    }

    wg.Wait() // 等待所有Goroutines完成

    fmt.Println("All downloads completed")
}

Dans le code ci-dessus, nous utilisons sync.WaitGroup pour synchroniser toutes les Goroutines. Au début de chaque Goroutine, nous incrémentons la valeur du compteur via wg.Add(1). A la fin de la Goroutine, on décrémente le compteur en defer wg.Done(). Enfin, nous utilisons wg.Wait() pour bloquer le thread principal jusqu'à ce que tous les Goroutines soient terminés.

Résumé :
En programmation concurrente, il est crucial d'utiliser les Goroutines de manière raisonnable et élégante. Grâce à une conception de concurrence raisonnable et à une gestion raisonnable des ressources, nous pouvons améliorer les performances et la fiabilité du programme. Cet article présente quelques bonnes pratiques pour appliquer élégamment Goroutines, dans l'espoir d'être utile aux lecteurs de la programmation simultanée Golang.

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!