## Concurrency Patterns ### Introduction aux modèles de concurrence Les modèles de concurrence offrent des approches structurées pour résoudre les défis complexes de programmation concurrente en utilisant des canaux (channels) en Golang. ### Modèles de concurrence courants avec les canaux #### 1. Modèle de pool de travailleurs (Worker Pool Pattern) ```mermaid graph LR A[Job Queue] --> B[Worker Pool] B --> C[Result Channel] ``` ```go func workerPool(jobs <-chan int, results chan<- int) { for job := range jobs { results <- processJob(job) } } func main() { jobs := make(chan int, 100) results := make(chan int, 100) // Create worker pool for w := 1; w <= 3; w++ { go workerPool(jobs, results) } // Send jobs for j := 1; j <= 5; j++ { jobs <- j } close(jobs) // Collect results for a := 1; a <= 5; a++ { <-results } } ``` #### 2. Modèle Fan-Out/Fan-In | Modèle | Description | Cas d'utilisation | | ------- | ------------------------------------------------ | ------------------------ | | Fan-Out | Un seul canal distribué à plusieurs travailleurs | Traitement parallèle | | Fan-In | Plusieurs canaux consolidés en un seul canal | Agrégation des résultats | ```go func fanOutFanIn() { ch1 := make(chan int) ch2 := make(chan int) ch3 := make(chan int) // Fan-Out go func() { for i := 0; i < 10; i++ { ch1 <- i ch2 <- i } close(ch1) close(ch2) }() // Fan-In go func() { for { select { case v, ok := <-ch1: if !ok { ch1 = nil } ch3 <- v case v, ok := <-ch2: if !ok { ch2 = nil } ch3 <- v } if ch1 == nil && ch2 == nil { close(ch3) return } } }() } ``` #### 3. Modèle de sémaphore (Semaphore Pattern) ```go type Semaphore struct { semaChan chan struct{} } func NewSemaphore(max int) *Semaphore { return &Semaphore{ semaChan: make(chan struct{}, max), } } func (s *Semaphore) Acquire() { s.semaChan <- struct{}{} } func (s *Semaphore) Release() { <-s.semaChan } ``` ### Modèles de concurrence avancés #### Modèle de pipeline (Pipeline Pattern) ```mermaid graph LR A[Stage 1] --> B[Stage 2] B --> C[Stage 3] ``` ```go func generateNumbers(max int) <-chan int { ch := make(chan int) go func() { for i := 1; i <= max; i++ { ch <- i } close(ch) }() return ch } func squareNumbers(input <-chan int) <-chan int { ch := make(chan int) go func() { for n := range input { ch <- n * n } close(ch) }() return ch } ``` ### Bonnes pratiques pour les modèles de concurrence 1. Utiliser les canaux pour la communication 2. Éviter le partage de mémoire 3. Concevoir pour la prévisibilité 4. Gérer gracieusement la fermeture des canaux ### Connaissances sur la concurrence de LabEx Chez LabEx, nous recommandons de pratiquer ces modèles grâce à des exercices de complexité progressive pour maîtriser les techniques de programmation concurrente. ### Conclusion Des modèles de concurrence efficaces permettent : - Une conception de système évolutive - Une utilisation efficace des ressources - Un code concurrent propre et maintenable