Maison >développement back-end >Golang >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.
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.
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 :
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 :
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!