How to use concurrency in Go with goroutines and channels

How concurrency works in Go

Go makes concurrency a first-class feature. A goroutine is a lightweight thread managed by the Go runtime; you start one by prefixing a call with go. Goroutines communicate by passing values over channels rather than sharing memory, which avoids many classic bugs. The motto is "share memory by communicating."

Prerequisites

• Go 1.21 or later
• Comfort with basic Go syntax

Steps

1. Start a goroutine

go func() {
    fmt.Println("running concurrently")
}()

The call returns immediately while the function runs in the background.

2. Communicate with channels

A channel is a typed conduit. Sends and receives block until both sides are ready, which synchronizes goroutines.

ch := make(chan int)
go func() { ch <- 42 }()
value := <-ch // receives 42

3. Wait for completion with WaitGroup

Use sync.WaitGroup to wait for a group of goroutines to finish.

var wg sync.WaitGroup
for _, job := range jobs {
    wg.Add(1)
    go func(j Job) {
        defer wg.Done()
        process(j)
    }(job)
}
wg.Wait()

4. Select across channels

select waits on multiple channel operations and proceeds with whichever is ready first.

select {
case v := <-ch1:
    use(v)
case <-time.After(time.Second):
    fmt.Println("timed out")
}

5. Cancel work with context

Pass a context.Context so callers can cancel long-running goroutines.

ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// goroutine returns when ctx.Done() fires

6. Detect races

Shared state without synchronization causes data races. The built-in detector finds them.

go test -race ./...
go run -race main.go

Verification

Write a program that launches several goroutines that send results over a channel, collect them with a WaitGroup, and print the total. Run it with -race and confirm no race is reported. Introduce an unsynchronized shared counter and confirm the detector flags it.

Next Steps

Learn worker pools, buffered channels, sync.Mutex for shared state, and errgroup for concurrent error handling.