Goroutines i kanały Go umożliwiają zestaw dobrze ugruntowanych **wzorców współbieżności**, które rozwiązują typowe problemy — dystrybucja pracy, fanning out/in, pipelines i rate limiting. Znając te idiomatyczne wzorce, możesz budować poprawne i wydajne systemy współbieżne. ## Worker pool — bounded concurrency ```go func workerPool(jobs <-chan int, results chan<- int, numWorkers int) { var wg sync.WaitGroup for w := 0; w < numWorkers; w++ { // a FIXED number of workers wg.Add(1) go func() { defer wg.Done() for job := range jobs { // each worker pulls jobs until the channel closes results <- process(job) } }() } wg.Wait() close(results) } ``` **Worker pool** uruchamia stałą liczbę goroutine'ów konsumujących z udostępnionego kanału jobs — ograniczając współbieżność (np. nie otwieraj 10 000 połączeń do bazy danych; używaj 10 workerów). To najważniejszy wzorzec do kontrolowania użycia zasobów. ## Fan-out / fan-in ```text Fan-out: distribute work across MULTIPLE goroutines (parallelize) Fan-in: MERGE results from multiple goroutines back into one channel ``` ```go // fan-in: merge several channels into one func merge(channels ...<-chan int) <-chan int { out := make(chan int) var wg sync.WaitGroup for _, ch := range channels { wg.Add(1) go func(c <-chan int) { defer wg.Done() for v := range c { out <- v } // forward each channel's values to out }(ch) } go func() { wg.Wait(); close(out) }() // close out when all sources are drained return out } ``` ## Pipeline — stages connected by channels ```go // each stage is a goroutine: receives from an input channel, sends to an output channel func generate(nums ...int) <-chan int { out := make(chan int) go func() { for _, n := range nums { out <- n }; close(out) }() return out } func square(in <-chan int) <-chan int { out := make(chan int) go func() { for n := range in { out <- n * n }; close(out) }() return out } // compose: square(generate(1,2,3)) → a streaming pipeline for result := range square(generate(1, 2, 3)) { fmt.Println(result) } ``` **Pipeline** łańcuchuje etapy przetwarzania za pośrednictwem kanałów — dane przepływają, każdy etap przekształca je współbieżnie. ## Rate limiting ```go limiter := time.Tick(200 * time.Millisecond) // a tick every 200ms for req := range requests { <-limiter // wait for the next tick before proceeding go handle(req) // → at most 5 requests/second } ``` ## Cancellation with context (cross-cutting) ```go select { case result := <-work: case <-ctx.Done(): return // stop on cancellation — prevents leaks } ``` ## Dlaczego to ważne Te wzorce współbieżności są praktycznym zestawem narzędzi do budowania rzeczywistych współbieżnych systemów Go, zamieniając surowe goroutines i kanały w ustrukturyzowane, poprawne rozwiązania dla powtarzających się problemów. **Worker pool** jest szczególnie ważny — ogranicza współbieżność w celu ochrony ograniczonych zasobów (połączenia z bazą danych, limity szybkości API, pamięć), zapobiegając typowemu błędowi uruchamiania nieograniczonych goroutine'ów, które wyczerpują system. **Fan-out/fan-in** paralelizuje pracę i scala wyniki; **pipelines** czyszczą modelowanie transformacji danych strumieniowych; **rate limiting** kontroluje przepustowość. W połączeniu z **anulowaniem opartym na kontekście** (aby uniknąć wycieków goroutine'ów), te wzorce to sposób, w jaki usługi Go w produkcji bezpiecznie i wydajnie obsługują współbieżność. Zrozumienie ich — a zwłaszcza wiedzenie, aby ograniczyć współbieżność za pomocą worker pools, a nie uruchamiać nieograniczone goroutine'y — jest cechą seniora w Go i częstym zaawansowanym tematem wywiadu, ponieważ naiwna współbieżność (nieograniczone goroutine'y, wycieki, wyścigi) jest częstą przyczyną awarii produkcji.

Golang pytań