Planificateur simultané Golang : implémentation optimisée de Go WaitGroup

Planificateur simultané Golang : implémentation optimisée de Go WaitGroup

Introduction :
Le langage Go fournit un moyen pratique d'écrire des programmes simultanés via le modèle de concurrence goroutine et le type WaitGroup dans le package de synchronisation intégré. Cependant, à mesure que la taille du programme augmente, l'utilisation d'un grand nombre de goroutines et de WaitGroups peut entraîner des goulots d'étranglement dans les performances. Afin d'optimiser ces problèmes, cet article présentera une méthode permettant de gérer plus efficacement les tâches simultanées.

1. Idées de conception d'un planificateur simultané :
Afin de mieux gérer les tâches simultanées, nous devons concevoir un planificateur simultané. Le planificateur simultané comprend principalement les composants suivants : file d'attente des tâches, pool de goroutines, fonction d'exécution des tâches et sémaphore. Les idées de conception du planificateur sont les suivantes :
1. File d'attente des tâches : utilisée pour stocker les tâches à exécuter. Sous la forme d'une file d'attente, les tâches sont retirées pour être exécutées lorsque le processus est inactif ;
2. pour gérer le nombre de goroutines. Limiter le nombre de goroutines pour éviter les problèmes de performances causés par la création et la destruction d'un grand nombre de goroutines ;
3. Fonction d'exécution de tâche : définie par l'utilisateur, représentant une logique d'exécution de tâche spécifique ; Sémaphore : utilisé pour contrôler le planificateur. L'état d'exécution garantit que toutes les tâches sont exécutées et terminées.

2. Implémentation spécifique du planificateur simultané :

Ce qui suit est un exemple de code basé sur l'implémentation optimisée du planificateur simultané Golang :

package main

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

// 定义任务结构体
type Task struct {
    TaskID int // 任务ID
}

func main() {
    var (
        tasksNumber = 100 // 待执行任务数量
        goroutineNum = 10 // goroutine数量
        wg sync.WaitGroup
        taskQueue = make(chan Task, tasksNumber) // 任务队列
    )
    // 初始化任务队列
    for i := 0; i < tasksNumber; i++ {
        task := Task{
            TaskID: i,
        }
        taskQueue <- task
    }
    close(taskQueue)

    // 启动goroutine
    for i := 0; i < goroutineNum; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for task := range taskQueue {
                execute(task)
            }
        }(i)
    }
    wg.Wait()
}

// 任务的具体执行函数
func execute(task Task) {
    fmt.Printf("TaskID: %d, Now: %s
", task.TaskID, time.Now().Format("2006-01-02 15:04:05"))
    time.Sleep(1 * time.Second)
    fmt.Printf("TaskID: %d, Finished
", task.TaskID)
}

Dans le code ci-dessus, nous créons d'abord une file d'attente de tâches (taskQueue) et la plaçons dans c'est une tâche à exécuter. Par la suite, nous avons démarré le pool de goroutines, et chaque goroutine a obtenu des tâches de la file d'attente des tâches et les a exécutées. Enfin, attendez que toutes les tâches soient terminées via l'objet WaitGroup.

3. Résumé :

Grâce à l'implémentation du code optimisé ci-dessus, nous pouvons mieux gérer les tâches simultanées et éviter les goulots d'étranglement de performances causés par l'utilisation d'un grand nombre de goroutines et de WaitGroups. La conception du planificateur simultané nous permet de gérer les tâches simultanées plus efficacement et d'améliorer la capacité de concurrence et les performances globales du programme.

De plus, pour des scénarios de concurrence plus complexes, nous pouvons encore améliorer les performances et la flexibilité du planificateur simultané en introduisant des pools de connexions, des priorités de tâches, des stratégies de planification, etc. J'espère que cet article pourra fournir aux lecteurs des références et de l'aide lors de l'écriture de programmes simultanés efficaces.

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!