Common concurrency patterns in Go

Introduction

Concurrency lets your program do many things at the same time. Common patterns help you organize this work safely and clearly.

When you want to download many files at once without waiting for each to finish.

When you need to handle multiple user requests in a web server simultaneously.

When you want to process data in stages, like reading, transforming, and saving, all at the same time.

When you want to share work between several workers to finish faster.

When you want to safely share data between parts of your program running at the same time.

Syntax

Go

package main

import (
	"fmt"
	"sync"
)

func main() {
	// Example of a concurrency pattern
}

Go uses goroutines to run functions concurrently.

Channels help goroutines communicate safely.

Examples

This starts a new goroutine that runs the function concurrently.

Go

go func() {
	fmt.Println("Hello from a goroutine")
}()

This shows how to send and receive data between goroutines using a channel.

Go

ch := make(chan int)
go func() {
	ch <- 42 // send value to channel
}()
val := <-ch // receive value from channel
fmt.Println(val)

WaitGroup waits for goroutines to finish before main exits.

Go

var wg sync.WaitGroup
wg.Add(1)
go func() {
	defer wg.Done()
	fmt.Println("Work done")
}()
wg.Wait()

This is a worker pool pattern where multiple workers process jobs concurrently.

Go

jobs := make(chan int, 3)
results := make(chan int, 3)

// Worker function
worker := func(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		fmt.Printf("worker %d started job %d\n", id, j)
		results <- j * 2
	}
}

func main() {
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}
	for j := 1; j <= 5; j++ {
		jobs <- j
	}
	close(jobs)
	for a := 1; a <= 5; a++ {
		fmt.Println("result:", <-results)
	}
}

Sample Program

This program uses a worker pool pattern. It starts 3 workers that get jobs from a channel. Each worker does some work (simulated by sleep) and sends results back. The main function waits for all workers to finish and then prints the results.

Go

package main

import (
	"fmt"
	"sync"
	"time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for j := range jobs {
		fmt.Printf("Worker %d started job %d\n", id, j)
		time.Sleep(time.Second) // simulate work
		fmt.Printf("Worker %d finished job %d\n", id, j)
		results <- j * 2
	}
}

func main() {
	jobs := make(chan int, 5)
	results := make(chan int, 5)
	var wg sync.WaitGroup

	// Start 3 workers
	for w := 1; w <= 3; w++ {
		wg.Add(1)
		go worker(w, jobs, results, &wg)
	}

	// Send 5 jobs
	for j := 1; j <= 5; j++ {
		jobs <- j
	}
	close(jobs)

	// Wait for all workers to finish
	wg.Wait()
	close(results)

	// Collect results
	for res := range results {
		fmt.Println("Result:", res)
	}
}

Important Notes

Always close channels when no more values will be sent to avoid deadlocks.

Use WaitGroup to wait for goroutines to finish before exiting main.

Be careful to avoid race conditions when sharing data between goroutines.

Summary

Concurrency lets your program do many things at once using goroutines.

Channels help goroutines talk to each other safely.

Common patterns like worker pools and WaitGroups help organize concurrent work clearly.

Practice

1. What is the primary purpose of a WaitGroup in Go concurrency?

easy

A. To limit the number of goroutines running at the same time

B. To send data safely between goroutines

C. To wait for a collection of goroutines to finish before continuing

D. To create new goroutines

Solution

1. Step 1: Understand WaitGroup's role

   A WaitGroup is used to wait for multiple goroutines to complete their work.

2. Step 2: Compare with other concurrency tools

   Channels send data, semaphores limit concurrency, and goroutines run functions concurrently.

3. Final Answer:

   To wait for a collection of goroutines to finish before continuing -> Option C

4. Quick Check:

   WaitGroup = wait for goroutines [OK]

Hint: WaitGroup waits for goroutines to finish, not for data passing [OK]

Common Mistakes:

• Confusing WaitGroup with channels
• Thinking WaitGroup limits goroutines
• Using WaitGroup to send data

2. Which of the following is the correct syntax to start a new goroutine calling function doWork()?

easy

A. run doWork()

B. goroutine doWork()

C. start doWork()

D. go doWork()

Solution

1. Step 1: Recall goroutine syntax

   In Go, the keyword go before a function call starts it as a goroutine.

2. Step 2: Check options

   Only go doWork() matches the correct syntax; others are invalid keywords.

3. Final Answer:

   go doWork() -> Option D

4. Quick Check:

   Start goroutine with 'go' keyword [OK]

Hint: Start goroutine with 'go' keyword before function call [OK]

Common Mistakes:

• Using non-existent keywords like 'goroutine' or 'start'
• Omitting 'go' keyword
• Trying to run goroutine without parentheses

3. What will be the output of this Go program?

package main
import (
  "fmt"
  "sync"
)
func main() {
  var wg sync.WaitGroup
  wg.Add(2)
  go func() {
    fmt.Println("Hello from goroutine 1")
    wg.Done()
  }()
  go func() {
    fmt.Println("Hello from goroutine 2")
    wg.Done()
  }()
  wg.Wait()
  fmt.Println("All goroutines finished")
}

medium

A. Hello from goroutine 2
Hello from goroutine 1

B. Hello from goroutine 1
Hello from goroutine 2
All goroutines finished

C. Hello from goroutine 1
All goroutines finished
Hello from goroutine 2

D. All goroutines finished
Hello from goroutine 1
Hello from goroutine 2

Solution

1. Step 1: Understand WaitGroup usage

   The program adds 2 to the WaitGroup, then starts 2 goroutines that each print a message and call wg.Done().

2. Step 2: Analyze output order

   The main goroutine waits for both goroutines to finish before printing "All goroutines finished". The two goroutine prints can appear in any order but both appear before the final print.

3. Final Answer:

   Hello from goroutine 1 Hello from goroutine 2 All goroutines finished -> Option B

4. Quick Check:

   WaitGroup ensures final print after goroutines [OK]

Hint: WaitGroup.Wait blocks until all Done calls complete [OK]

Common Mistakes:

• Assuming main prints before goroutines
• Ignoring WaitGroup synchronization
• Expecting goroutine prints after final print

4. Identify the error in this Go code snippet using channels:

package main
import "fmt"
func main() {
  ch := make(chan int)
  go func() {
    ch <- 10
  }()
  fmt.Println(<-ch)
  fmt.Println(<-ch)
}

medium

A. Second read from channel blocks forever

B. Channel is not closed before reading

C. Channel should be buffered to send data

D. Goroutine is not started correctly

Solution

1. Step 1: Analyze channel sends and receives

   The goroutine sends one value (10) into the channel. The main goroutine reads twice from the channel.

2. Step 2: Identify blocking behavior

   The first read gets 10 successfully. The second read waits for another value that never comes, causing a deadlock (blocks forever).

3. Final Answer:

   Second read from channel blocks forever -> Option A

4. Quick Check:

   One send, two receives causes blocking [OK]

Hint: Reads must match sends; extra read blocks forever [OK]

Common Mistakes:

• Thinking channel must be closed before reading
• Assuming buffered channel fixes blocking here
• Believing goroutine not started properly

5. You want to create a worker pool in Go to process 5 jobs concurrently but limit to 2 workers at a time. Which pattern correctly implements this?

hard

A. Use a buffered channel of size 2 as a semaphore to limit goroutines, and a WaitGroup to wait for all jobs

B. Start 5 goroutines without limit and use a WaitGroup to wait

C. Use an unbuffered channel to send jobs and no WaitGroup

D. Use a mutex to lock and unlock workers

Solution

1. Step 1: Understand worker pool concurrency limit

   To limit concurrent workers, a buffered channel (semaphore) of size 2 can control how many goroutines run simultaneously.

2. Step 2: Use WaitGroup to wait for all jobs

   A WaitGroup tracks all 5 jobs to ensure main waits until all finish before exiting.

3. Final Answer:

   Use a buffered channel of size 2 as a semaphore to limit goroutines, and a WaitGroup to wait for all jobs -> Option A

4. Quick Check:

   Semaphore + WaitGroup = controlled concurrency [OK]

Hint: Semaphore channel limits workers; WaitGroup waits for all [OK]

Common Mistakes:

• Starting all goroutines without limit
• Not using WaitGroup to wait for completion
• Using mutex incorrectly for concurrency limit