Modèles de concurrence dans Go ; pools de travailleurs et répartition/dépannage

Go est connu pour son modèle de concurrence exceptionnel, mais de nombreux développeurs se concentrent uniquement sur les goroutines et les canaux. Cependant, les modèles de concurrence tels que les pools de nœuds de calcul et le fan-out/fan-in offrent une réelle efficacité.

Cet article abordera ces concepts avancés, vous aidant à maximiser le débit de vos applications Go.

Pourquoi la concurrence est importante

La concurrence permet aux programmes d'effectuer des tâches efficacement, en particulier lorsqu'il s'agit de tâches telles que les opérations d'E/S, les requêtes Web ou le traitement en arrière-plan. Dans Go, les goroutines offrent un moyen léger de gérer des milliers de tâches simultanées, mais sans structure, vous pouvez vous heurter à des goulots d'étranglement. C'est là qu'interviennent les pools de travailleurs et les modèles de répartition/d'arrivée.

Pools de travailleurs

Les pools de travailleurs vous permettent de limiter le nombre de goroutines en attribuant des tâches à des « travailleurs » fixes. Cela évite le surabonnement, réduit la consommation de ressources et rend l'exécution des tâches gérable.

package main

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

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second) // Simulate work
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    var wg sync.WaitGroup

    // Start 3 workers
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // Send jobs
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    // Wait for workers to finish
    wg.Wait()
    close(results)

    for result := range results {
        fmt.Println("Result:", result)
    }
}

Dans cet exemple :

• Nous avons trois travailleurs qui traitent les tâches simultanément.
• Chaque travail est transmis aux travailleurs via des canaux et les résultats sont collectés pour traitement.

Modèle de diffusion/sortie d'entrée

Le modèle fan-out/fan-in permet à plusieurs goroutines de traiter la même tâche, tandis que le fan-in rassemble les résultats en une seule sortie. Ceci est utile pour diviser les tâches puis agréger les résultats.

package main

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

func workerFanOut(id int, tasks <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for task := range tasks {
        fmt.Printf("Worker %d processing task %d\n", id, task)
        time.Sleep(time.Second) // Simulate work
    }
}

func main() {
    var wg sync.WaitGroup
    tasks := make(chan int, 10)

    // Fan-out: Launch multiple workers
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go workerFanOut(i, tasks, &wg)
    }

    // Send tasks
    for i := 1; i <= 9; i++ {
        tasks <- i
    }
    close(tasks)

    // Wait for workers to finish
    wg.Wait()

    fmt.Println("All tasks are processed.")
}

Dans le code ci-dessus :

• Fan-Out : Nous créons plusieurs goroutines (travailleurs) qui gèrent les tâches simultanément.
• Fan-In : après le traitement, les résultats de tous les travailleurs peuvent être regroupés pour un traitement ultérieur.

---

Les modèles de concurrence peuvent être appliqués pour optimiser les serveurs Web, les systèmes de traitement par lots ou les applications liées aux E/S. L'utilisation de modèles tels que les pools de nœuds de calcul et la distribution/distribution garantit une utilisation optimale des ressources sans surcharger la capacité du système.

Prochaines étapes pour approfondir vos connaissances :

• Découvrez comment ces modèles peuvent être étendus à d'autres défis de concurrence.
• Créez un service Web en temps réel avec un pool de travailleurs gérant les requêtes.

La clé du succès dans la concurrence de Go est la structure. La maîtrise de ces modèles de concurrence améliorera vos compétences Go et vous aidera à écrire des applications hautement performantes.

Restez à l'écoute pour plus d'informations sur Go dans le prochain article !

Vous pouvez me soutenir en m'achetant un livre :)

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!