Go Concurrency

Core Principle

“Do not communicate by sharing memory; instead, share memory by communicating.”

Pass data ownership through channels. Only one goroutine accesses a value at a time — data races cannot occur by design.

Goroutines

// Launch with go keyword — lightweight, cheap to create
go list.Sort()

// Anonymous goroutine with closure
go func() {
    time.Sleep(delay)
    fmt.Println(message)
}()

Channels

Unbuffered vs Buffered

// Unbuffered — synchronization point
done := make(chan struct{})
go func() {
    doWork()
    done <- struct{}{}  // signal completion
}()
<-done  // wait

// Buffered — decouple producer/consumer
jobs := make(chan Job, 100)

Channel Direction

// Send-only
func producer(out chan<- int) { out <- 42 }

// Receive-only
func consumer(in <-chan int) { v := <-in }

Range Over Channel

// Iterate until channel closed
for msg := range ch {
    process(msg)
}
// Loop exits when ch is closed and drained

Closing Channels

Select

select {
case v := <-ch1:
    process(v)
case ch2 <- result:
    // sent
case <-time.After(5 * time.Second):
    // timeout
default:
    // non-blocking — runs if no channel ready
}

Common Patterns

Semaphore (limit concurrency)

var sem = make(chan struct{}, MaxConcurrent)

func handle(r *Request) {
    sem <- struct{}{}   // acquire
    defer func() { <-sem }()  // release
    process(r)
}

Worker Pool

func worker(id int, jobs <-chan Job, results chan<- Result) {
    for job := range jobs {
        results <- process(job)
    }
}

func main() {
    jobs := make(chan Job, 100)
    results := make(chan Result, 100)

    // Start workers
    for w := 0; w < numWorkers; w++ {
        go worker(w, jobs, results)
    }

    // Send jobs
    for _, job := range allJobs {
        jobs <- job
    }
    close(jobs)

    // Collect results
    for range allJobs {
        r := <-results
        handle(r)
    }
}

Fan-out, Fan-in

// Fan-out: multiple goroutines read from same channel
// Fan-in: single goroutine reads from multiple channels
func fanIn(channels ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    merged := make(chan int)

    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                merged <- v
            }
        }(ch)
    }

    go func() {
        wg.Wait()
        close(merged)
    }()

    return merged
}

Resource Pool (Leaky Buffer)

var pool = make(chan *Buffer, 100)

func getBuffer() *Buffer {
    select {
    case b := <-pool:
        return b  // reuse
    default:
        return new(Buffer)  // allocate new
    }
}

func putBuffer(b *Buffer) {
    b.Reset()
    select {
    case pool <- b:
        // returned to pool
    default:
        // pool full — GC will reclaim
    }
}

Done Channel / Context Cancellation

// Done channel pattern
func worker(done <-chan struct{}, jobs <-chan Job) {
    for {
        select {
        case <-done:
            return  // shutdown
        case job := <-jobs:
            process(job)
        }
    }
}

// Context pattern (preferred)
func worker(ctx context.Context, jobs <-chan Job) {
    for {
        select {
        case <-ctx.Done():
            return
        case job := <-jobs:
            process(job)
        }
    }
}

sync Primitives

// WaitGroup — wait for all goroutines
var wg sync.WaitGroup
for _, item := range items {
    wg.Add(1)
    go func(it Item) {
        defer wg.Done()
        process(it)
    }(item)
}
wg.Wait()

// Once — thread-safe lazy init
var once sync.Once
var instance *Config
func GetConfig() *Config {
    once.Do(func() {
        instance = loadConfig()
    })
    return instance
}

Context Rules

// BAD: context in struct
type Service struct {
    ctx context.Context  // Don't do this
}

// GOOD: context as first parameter
func (s *Service) Process(ctx context.Context, data Data) error {
    return s.db.QueryContext(ctx, query)
}

Prefer Synchronous Functions

// BAD: forcing async on callers
func FetchData() <-chan Result {
    ch := make(chan Result)
    go func() { ch <- doFetch() }()
    return ch
}

// GOOD: let caller add concurrency if needed
func FetchData(ctx context.Context) (Result, error) {
    return doFetch(ctx)
}

// Caller can easily wrap if they need async:
go func() { result, err := FetchData(ctx); ... }()

Parallelization

numCPU := runtime.NumCPU()
c := make(chan bool, numCPU)

for i := 0; i < numCPU; i++ {
    go func(start, end int) {
        processRange(data[start:end])
        c <- true
    }(i*len(data)/numCPU, (i+1)*len(data)/numCPU)
}

for i := 0; i < numCPU; i++ {
    <-c  // wait for all
}

Common Mistakes