Comment éviter les blocages lors de la collecte des résultats des Goroutines en Go ?

Utiliser des Goroutines pour traiter des valeurs et rassembler les résultats en une tranche

Les Goroutines sont un concept fondamental dans Go pour la programmation simultanée. Ils vous permettent d'exécuter plusieurs tâches simultanément sans bloquer le thread principal. Cependant, l'utilisation de goroutines peut s'avérer délicate, en particulier lorsqu'il s'agit de collecter les résultats de plusieurs goroutines.

Énoncé du problème

Un développeur a tenté d'utiliser des goroutines pour traiter une liste de goroutines. éléments et collecter les valeurs traitées dans une tranche. Cependant, ils ont rencontré le redoutable « tous les goroutines sont endormis – impasse ! » erreur.

Cause première du blocage

Le blocage s'est produit parce que le code attendait que toutes les goroutines terminent le traitement avant de tenter de collecter les résultats. Cela a créé une situation dans laquelle les goroutines attendaient que la tranche soit disponible pour écrire, tandis que le thread principal attendait que les goroutines terminent le traitement.

Solution

Pour résoudre le blocage, il est nécessaire d'introduire une fermeture asynchrone du canal utilisé pour communiquer entre les goroutines et le thread principal. Le code modifié ci-dessous montre la solution :

// ...

// Create a channel to receive the processed values
sampleChan := make(chan sample)

var wg sync.WaitGroup

// Process each item in the list with a goroutine
for i, line := range contents {
    wg.Add(1)
    go func(line string) {
        defer wg.Done()
        // Process the item and send the result on the channel
        sampleChan <- newSample(line, *replicatePtr, *timePtr)
    }(line)
}

// Asyncronously close the channel when all goroutines are done
go func() {
    wg.Wait()
    close(sampleChan)
}()

// Read from the channel and gather results into a slice
var sampleList []sample
for s := range sampleChan {
    sampleList = append(sampleList, s)
}

// ...

En fermant le canal de manière asynchrone, le thread principal peut procéder à la collecte des résultats même pendant que les goroutines sont encore en traitement. Cela sort de l'impasse et permet au code de s'exécuter correctement.

Considérations supplémentaires

Il convient de noter que même si cette solution résout l'impasse, ce n'est pas une solution complète pour gérer la concurrence dans ce scénario spécifique. En fonction des exigences et du nombre de goroutines, des mécanismes supplémentaires de synchronisation et de gestion des erreurs peuvent être nécessaires pour garantir la fiabilité et l'exactitude du code.

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!