go-concurrency

Goroutines are lightweight threads managed by the Go runtime; launch them with the `go` keyword. Channels enable safe communication between goroutines. Use unbuffered channels for synchronization, buffered channels for queuing, and the `select` statement to multiplex multiple channel operations. Coordinate completion with `WaitGroup` or channel closing semantics.

Worker pools use goroutines that receive tasks from a channel, process them, and signal completion. Spawn a fixed number of worker goroutines, send work through an input channel, collect results on an output channel, and use `WaitGroup` to wait for all workers to finish. This pattern prevents goroutine explosion and controls resource usage.

Avoid data races by either using channels to communicate ownership or by protecting shared data with synchronization primitives. `Mutex` locks critical sections for exclusive access; `RWMutex` allows concurrent reads with exclusive writes; `Once` ensures one-time initialization. Choose based on contention patterns and access frequency.

Yes. Use `time.After()` or `time.Tick()` to create timeout channels, then combine them with `select` to handle both completion and timeout cases. This pattern prevents goroutines from blocking indefinitely and enables graceful degradation when operations exceed acceptable time limits.

Unbuffered channels synchronize goroutines—the sender blocks until a receiver is ready. Buffered channels queue messages up to their capacity, allowing senders to proceed without an immediate receiver. Use unbuffered for tight coordination, buffered when you need decoupling or producer-consumer rate differences.

Failing to close a channel leaves goroutines waiting indefinitely, causing deadlocks or resource leaks. Close channels only from the sender side once no more values will be sent. Receivers can distinguish closure from values using the comma-ok idiom. Synchronization primitives like `WaitGroup` help coordinate clean shutdown.