Programmation simultanée Golang : utiliser Go WaitGroup pour implémenter le planificateur de tâches

Programmation simultanée Golang : utilisez Go WaitGroup pour implémenter le planificateur de tâches

1. Introduction
   Dans Golang, la mise en œuvre de la programmation simultanée peut considérablement améliorer les performances et l'efficacité du programme. Le planificateur de tâches est un élément très important de la programmation simultanée. Il peut être utilisé pour planifier la séquence d'exécution de tâches simultanées et l'achèvement de tâches synchronisées. Cet article expliquera comment utiliser WaitGroup dans Golang pour implémenter un planificateur de tâches simple et donnera des exemples de code spécifiques.
2. Introduction à WaitGroup
   WaitGroup est un type important dans la synchronisation du package Golang, qui fournit des fonctions de synchronisation et d'attente pour les tâches simultanées. WaitGroup a trois méthodes principales : Ajouter, Terminé et Attendre.

• Add(n int) : Ajoutez n tâches simultanées à WaitGroup.
• Done() : marque une tâche comme terminée.
• Wait() : attendez que toutes les tâches soient terminées et bloquez la goroutine actuelle.

WaitGroup maintient un compteur en interne pour enregistrer le nombre de tâches inachevées. Lorsque la méthode Add est appelée, le compteur est incrémenté de la valeur spécifiée ; lorsque la méthode Done est appelée, le compteur est décrémenté de 1 lorsque la méthode Wait est appelée, si le compteur est supérieur à 0, la goroutine actuelle sera bloqué jusqu'à ce que le compteur revienne à zéro.

3. Implémentation du planificateur de tâches
   Voici un exemple de code qui utilise WaitGroup pour implémenter un planificateur de tâches :

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting
", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    wg.Wait()
    fmt.Println("All workers done")
}

Dans cet exemple, nous utilisons une boucle for pour démarrer 5 goroutines de travail et appelons wg.Add(1) pour ajouter le nombre de tâches au WaitGroup. Dans la fonction de travail, utilisez le mot-clé defer pour vous assurer que wg.Done() est appelé avant que la fonction ne revienne pour décrémenter la valeur du compteur. Enfin, utilisez wg.Wait() pour attendre que toutes les tâches soient terminées.

4. Exécuter les résultats
   Exécutez cet exemple de code, vous verrez le résultat suivant :

Worker 1 starting
Worker 2 starting
Worker 3 starting
Worker 4 starting
Worker 5 starting
Worker 3 done
Worker 1 done
Worker 2 done
Worker 5 done
Worker 4 done
All workers done

Vous pouvez voir que toutes les goroutines de travail sont exécutées simultanément, mais l'ordre de sortie n'est pas nécessairement dans l'ordre de démarrage. la planification est effectuée par le runtime Go.

5. Résumé
   L'utilisation de WaitGroup peut facilement implémenter la planification et la synchronisation de tâches simultanées. La synchronisation et le contrôle séquentiel des tâches peuvent être obtenus en appelant la méthode Add pour ajouter le nombre de tâches, en appelant la méthode Done pour marquer l'achèvement de la tâche et en appelant la méthode Wait pour attendre l'achèvement de la tâche. Dans les applications pratiques, le planificateur de tâches peut être utilisé pour gérer des tâches simultanées, limiter le nombre de simultanéités et d'autres scénarios, nous aidant ainsi à mieux utiliser les capacités de simultanéité de Golang.

Grâce à l'introduction et à l'exemple de code de cet article, je pense que vous comprenez mieux comment utiliser WaitGroup de Golang pour implémenter un planificateur de tâches. J'espère que cet article vous aidera à apprendre et à utiliser la programmation simultanée dans 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!