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)
graph LR
A[Job Queue] --> B[Worker Pool]
B --> C[Result Channel]
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 |
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)
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)
graph LR
A[Stage 1] --> B[Stage 2]
B --> C[Stage 3]
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
- Utiliser les canaux pour la communication
- Éviter le partage de mémoire
- Concevoir pour la prévisibilité
- 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