Programmation simultanée Golang : utilisation de Go WaitGroup pour implémenter la file d'attente des tâches

Programmation simultanée Golang : Utiliser Go WaitGroup pour implémenter des files d'attente de tâches

Avec l'amélioration continue des performances des ordinateurs, la programmation simultanée utilisant des processeurs multicœurs est devenue une compétence essentielle. En tant que langage de programmation mettant l'accent sur la concurrence, Golang fournit un modèle de concurrence simple et puissant, permettant aux développeurs d'utiliser plus facilement les processeurs multicœurs.

Dans Golang, WaitGroup est un mécanisme utilisé pour coordonner la synchronisation entre les goroutines. Il définit le compteur sur une valeur non nulle avant de démarrer la goroutine, puis décrémente le compteur une fois que chaque goroutine a terminé son travail. Lorsque la valeur du compteur est 0, cela signifie que toutes les goroutines ont terminé leurs tâches et peuvent continuer à effectuer les opérations suivantes.

Dans cet article, nous utiliserons WaitGroup pour implémenter une file d'attente de tâches simple afin de montrer comment utiliser ce mécanisme pour implémenter la programmation simultanée. Plus précisément, nous implémenterons un programme de gestion de fichiers simple capable de gérer plusieurs fichiers en même temps.

Tout d'abord, nous devons définir une structure pour représenter la tâche fichier :

type FileTask struct {
    filename string
}

func (task *FileTask) Process() {
    // 文件处理逻辑
}

Dans le code ci-dessus, la structure FileTask représente une tâche fichier, qui contient un champ de nom de fichier. La méthode Process est utilisée pour la logique réelle de traitement du fichier.

Ensuite, nous définissons une file d'attente de tâches :

type TaskQueue struct {
    tasks []FileTask
    wg    sync.WaitGroup
}

func (queue *TaskQueue) Add(task FileTask) {
    queue.tasks = append(queue.tasks, task)
}

func (queue *TaskQueue) StartWorkers(numWorkers int) {
    for i := 0; i < numWorkers; i++ {
        go queue.worker()
    }
}

func (queue *TaskQueue) worker() {
    defer queue.wg.Done()

    for {
        task, ok := queue.getNextTask()

        if !ok {
            return
        }

        task.Process()
    }
}

func (queue *TaskQueue) getNextTask() (FileTask, bool) {
    if len(queue.tasks) == 0 {
        return FileTask{}, false
    }

    task := queue.tasks[0]
    queue.tasks = queue.tasks[1:]

    return task, true
}

func (queue *TaskQueue) Wait() {
    queue.wg.Wait()
}

Le code ci-dessus définit une structure TaskQueue, qui contient une file d'attente de tâches et un WaitGroup. La méthode Add est utilisée pour ajouter des tâches à la file d'attente et la méthode StartWorkers démarre un nombre spécifié de goroutines de travail. Chaque travailleur continuera à obtenir des tâches de la file d'attente et à les exécuter jusqu'à ce que la file d'attente soit vide. La méthode getNextTask est utilisée pour obtenir la tâche suivante de la file d'attente et renvoie false si la file d'attente est vide. Enfin, la méthode Wait est utilisée pour attendre que toutes les goroutines de travail terminent leurs tâches.

Enfin, nous pouvons utiliser la file d'attente de tâches ci-dessus pour traiter les fichiers :

func main() {
    queue := TaskQueue{}

    for _, filename := range filenames {
        task := FileTask{filename: filename}
        queue.Add(task)
    }

    queue.StartWorkers(numWorkers)
    queue.Wait()
}

Dans le code ci-dessus, nous créons d'abord une file d'attente vide, puis parcourons tous les noms de fichiers, construisons chaque nom de fichier dans un objet de tâche et ajoutons à la file d'attente. Ensuite, nous démarrons un nombre spécifié de goroutines de travail, qui récupéreront les tâches de la file d'attente et les traiteront. Enfin, nous appelons la méthode Wait pour attendre que tous les traitements des tâches soient terminés.

Grâce aux exemples de code ci-dessus, nous pouvons voir que l'utilisation de Go WaitGroup pour implémenter des files d'attente de tâches est très simple et intuitive. Il nous suffit de définir les structures des tâches et des files d'attente, d'écrire les méthodes correspondantes pour réaliser la distribution et l'exécution des tâches, et d'attendre que toutes les tâches soient terminées.

Résumé :
L'utilisation de Go WaitGroup pour implémenter des files d'attente de tâches est une technologie de programmation simultanée simple et puissante. En utilisant rationnellement WaitGroup et goroutine, nous pouvons exploiter pleinement les performances des processeurs multicœurs et mettre en œuvre des programmes simultanés efficaces. Par conséquent, lors de la programmation simultanée Golang, une utilisation raisonnable de WaitGroup est très utile pour implémenter des files d'attente de tâches.

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!