Modèle de concurrence de générateur dans Go : un guide complet

⚠️ Comment s'y prendre pour cette série ?

1. Exécutez chaque exemple : Ne vous contentez pas de lire le code. Tapez-le, exécutez-le et observez le comportement.
2. Expérimentez et cassez des choses : Supprimez les mises en veille et voyez ce qui se passe, modifiez la taille des tampons de canal, modifiez le nombre de goroutines.
Casser des choses vous apprend comment elles fonctionnent
3. Raison concernant le comportement : Avant d'exécuter du code modifié, essayez de prédire le résultat. Lorsque vous constatez un comportement inattendu, faites une pause et réfléchissez à pourquoi. Contestez les explications.
4. Construire des modèles mentaux : Chaque visualisation représente un concept. Essayez de dessiner vos propres diagrammes pour le code modifié.

Dans notre article précédent, nous avons exploré les bases des goroutines et des canaux, les éléments constitutifs de la concurrence de Go. Lire ici :

Comprendre et visualiser les Goroutines et les canaux en Golang

Souvik Kar Mahapatra ・ 20 décembre

#aller #programmation #apprentissage #tutoriel

Voyons maintenant comment ces primitives se combinent pour former des modèles puissants qui résolvent des problèmes du monde réel.

Dans cet article, nous aborderons le Modèle de générateur et essaierons de les visualiser. Alors préparons-nous car nous serons présents tout au long du processus.

Modèle de générateur

Un générateur est comme une fontaine qui produit en continu des valeurs que nous pouvons consommer à tout moment.

Dans Go, c'est une fonction qui produit un flux de valeurs et les envoie via un canal, permettant à d'autres parties de notre programme de recevoir ces valeurs à la demande.

Regardons un exemple :

// generateNumbers creates a generator that produces numbers from 1 to max
func generateNumbers(max int) chan int {
    // Create a channel to send numbers
    out := make(chan int)

    // Launch a goroutine to generate numbers
    go func() {
        // Important: Always close the channel when done
        defer close(out)

        for i := 1; i <= max; i++ {
            out <- i  // Send number to channel
        }
    }()

    // Return channel immediately
    return out
}

// Using the generator
func main() {
    // Create a generator that produces numbers 1-5
    numbers := generateNumbers(5)

    // Receive values from the generator
    for num := range numbers {
        fmt.Println("Received:", num)
    }
}

Dans cet exemple, notre fonction génératrice fait trois choses clés :

1. Crée un canal pour envoyer des valeurs
2. Lance une goroutine pour générer des valeurs
3. Renvoie immédiatement le canal pour que les consommateurs puissent l'utiliser

Pourquoi utiliser des générateurs ?

1. Séparer la production de valeur de la consommation
2. Générer des valeurs à la demande (évaluation paresseuse)
3. Peut représenter des séquences infinies sans consommer de mémoire infinie
4. Autoriser la production et la consommation simultanées de valeurs

Cas d'utilisation réel

Lecture de fichiers volumineux ligne par ligne :

func generateLines(filename string) chan string {
    out := make(chan string)
    go func() {
        defer close(out)
        file, err := os.Open(filename)
        if err != nil {
            return
        }
        defer file.Close()

        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            out <- scanner.Text()
        }
    }()
    return out
}

Maintenant, vous vous demandez peut-être : qu'est-ce qu'il a de si spécial ? nous pouvons faire la même chose, comme générer une séquence de données ou lire ligne par ligne sans goroutines. N'est-ce pas exagéré ? Essayons de visualiser les deux cas :

Sans les goroutines

// Traditional approach
func getNumbers(max int) []int {
    numbers := make([]int, max)
    for i := 1; i <= max; i++ {
        numbers[i-1] = i
        // Imagine some heavy computation here
        time.Sleep(100 * time.Millisecond)
    }
    return numbers
}

Ici, vous devez attendre que tout soit prêt avant de pouvoir commencer le traitement.

Avec les goroutines

// Generator approach
func generateNumbers(max int) chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for i := 1; i <= max; i++ {
            out <- i
            // Same heavy computation
            time.Sleep(100 * time.Millisecond)
        }
    }()
    return out
}

Vous pouvez commencer à traiter les données pendant que les données sont encore en cours de génération.

Principaux avantages du modèle de générateur :

1. Exécution non bloquante : la génération et le traitement s'effectuent simultanément

2. Efficacité de la mémoire : Peut générer et traiter une valeur à la fois, pas besoin de stocker immédiatement dans la mémoire

3. Séquences infinies : Peut générer des séquences infinies sans problèmes de mémoire

4. Gestion de la contre-pression : Si votre consommateur est lent, le générateur ralentit naturellement (en raison du blocage des canaux), évitant ainsi la surcharge de la mémoire.
   

// generateNumbers creates a generator that produces numbers from 1 to max
func generateNumbers(max int) chan int {
    // Create a channel to send numbers
    out := make(chan int)

    // Launch a goroutine to generate numbers
    go func() {
        // Important: Always close the channel when done
        defer close(out)

        for i := 1; i <= max; i++ {
            out <- i  // Send number to channel
        }
    }()

    // Return channel immediately
    return out
}

// Using the generator
func main() {
    // Create a generator that produces numbers 1-5
    numbers := generateNumbers(5)

    // Receive values from the generator
    for num := range numbers {
        fmt.Println("Received:", num)
    }
}

Pièges courants et solutions

1. Oublier de fermer les chaînes

func generateLines(filename string) chan string {
    out := make(chan string)
    go func() {
        defer close(out)
        file, err := os.Open(filename)
        if err != nil {
            return
        }
        defer file.Close()

        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            out <- scanner.Text()
        }
    }()
    return out
}

1. Ne pas gérer les erreurs

// Traditional approach
func getNumbers(max int) []int {
    numbers := make([]int, max)
    for i := 1; i <= max; i++ {
        numbers[i-1] = i
        // Imagine some heavy computation here
        time.Sleep(100 * time.Millisecond)
    }
    return numbers
}

1. Fuites de ressources : lorsque vous utilisez des générateurs avec des ressources (comme des fichiers), assurez-vous d'un nettoyage approprié :

// Generator approach
func generateNumbers(max int) chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for i := 1; i <= max; i++ {
            out <- i
            // Same heavy computation
            time.Sleep(100 * time.Millisecond)
        }
    }()
    return out
}

C'est tout pour le modèle du générateur. La prochaine étape est le Modèle de concurrence de pipeline. Restez à l'écoute pour clarifier vos concepts sur la concurrence Golang.

Est-ce que j'ai raté quelque chose ? Vous avez des questions ? Vous avez quelque chose d'intéressant à partager ? Tous les commentaires sont les bienvenus.

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!