Concurrent execution model in Go - Deep Dive

Overview - Concurrent execution model

What is it?

The concurrent execution model is a way to run multiple tasks at the same time in a program. It helps programs do many things without waiting for one task to finish before starting another. In Go, this is done using goroutines, which are lightweight threads managed by the Go runtime. This model allows efficient use of CPU and improves program responsiveness.

Why it matters

Without concurrency, programs would do tasks one after another, making them slow and unresponsive, especially when waiting for things like files or network data. Concurrency lets programs handle many tasks at once, like serving many users or processing data quickly. This makes software faster and better at using modern multi-core computers.

Where it fits

Before learning concurrency, you should understand basic Go syntax, functions, and how programs run sequentially. After concurrency, you can learn about synchronization, channels, parallelism, and advanced patterns like worker pools or pipelines.

Mental Model

Core Idea

Concurrency is about managing multiple tasks that can start, run, and complete independently, often overlapping in time to improve efficiency.

Think of it like...

Imagine a kitchen where one cook can prepare many dishes by starting one, then while it cooks, starting another, and so on. They switch between tasks so nothing waits idle, making the kitchen work faster overall.

┌───────────────┐
│ Main Program  │
└──────┬────────┘
       │
       ▼
┌───────────────┐      ┌───────────────┐
│ Goroutine 1   │      │ Goroutine 2   │
│ (Task 1)     │      │ (Task 2)     │
└───────────────┘      └───────────────┘
       │                      │
       ▼                      ▼
  (Runs independently, overlapping in time)

Build-Up - 6 Steps

1

Foundation

Understanding Sequential Execution

Concept: Programs run one instruction at a time in order.

In Go, when you write code, it runs from top to bottom. For example, if you print two messages, the first prints before the second. This is called sequential execution.

Result

Output shows messages printed one after another.

Understanding sequential execution is key because concurrency changes this order to improve efficiency.

2

Foundation

Introducing Goroutines for Concurrency

Concept: Goroutines let you run functions concurrently with simple syntax.

In Go, you add the keyword 'go' before a function call to start it as a goroutine. This means the function runs independently while the main program continues.

Result

Multiple functions run at the same time, overlapping their execution.

Knowing goroutines are lightweight threads helps you write programs that do many things at once without heavy resource use.

3

Intermediate

How Goroutines Share Memory

🤔Before reading on: do you think goroutines have separate memory or share the same memory? Commit to your answer.

Concept: Goroutines share the same memory space, which can cause conflicts if not managed.

All goroutines in a program share the same memory. If two goroutines change the same variable at the same time, it can cause errors called race conditions.

Result

Race conditions cause unpredictable program behavior or crashes.

Understanding shared memory is crucial to avoid bugs and ensure safe concurrent programs.

4

Intermediate

Using Channels for Safe Communication

🤔Before reading on: do you think channels send data by copying or by sharing memory? Commit to your answer.

Concept: Channels let goroutines send and receive data safely without sharing memory directly.

Channels are like pipes where one goroutine sends data and another receives it. This avoids conflicts because data moves safely between goroutines.

Result

Programs communicate safely and avoid race conditions.

Channels provide a simple way to coordinate goroutines and prevent common concurrency bugs.

5

Advanced

Goroutine Scheduling by Go Runtime

🤔Before reading on: do you think goroutines map one-to-one to OS threads? Commit to your answer.

Concept: The Go runtime schedules many goroutines onto fewer OS threads efficiently.

Goroutines are multiplexed onto OS threads by the Go scheduler. This means thousands of goroutines can run with only a few threads, saving resources and improving performance.

Result

High concurrency with low overhead and efficient CPU use.

Knowing how scheduling works helps optimize program design and troubleshoot performance issues.

6

Expert

Avoiding Deadlocks and Starvation

🤔Before reading on: do you think deadlocks happen only with many goroutines or can two goroutines cause deadlock? Commit to your answer.

Concept: Deadlocks happen when goroutines wait forever for each other, and starvation when some goroutines never get CPU time.

Deadlocks occur if goroutines wait on channels or locks that never become available. Starvation happens if the scheduler favors some goroutines over others. Proper design and tools like 'go vet' help detect these issues.

Result

Programs run smoothly without freezing or ignoring tasks.

Understanding these pitfalls is essential for building reliable concurrent systems.

Under the Hood

Goroutines are managed by the Go runtime scheduler, which maps many goroutines onto a smaller number of OS threads. Each goroutine has a small stack that grows and shrinks dynamically. The scheduler handles goroutine states like runnable, waiting, or running, switching between them to maximize CPU use. Channels use internal queues and synchronization primitives to safely pass data between goroutines without race conditions.

Why designed this way?

Go was designed to make concurrency easy and efficient. Traditional OS threads are heavy and costly to create, so Go uses lightweight goroutines to allow thousands of concurrent tasks. The scheduler abstracts complexity from the programmer, and channels provide a safe communication method inspired by CSP (Communicating Sequential Processes) theory. This design balances simplicity, safety, and performance.

┌───────────────┐
│ Go Runtime    │
│ Scheduler    │
└──────┬────────┘
       │
┌──────┴─────────────┐
│ OS Threads (few)    │
│ ┌───────────────┐  │
│ │ Goroutine 1   │  │
│ │ Goroutine 2   │  │
│ │ ...           │  │
│ └───────────────┘  │
└────────────────────┘

Channels:
Sender ──> [Channel Queue] ──> Receiver

Myth Busters - 4 Common Misconceptions

Quick: Do goroutines run in parallel by default? Commit to yes or no.

Common Belief: Goroutines always run in parallel on multiple CPU cores.

Reality: Goroutines run concurrently but may not run in parallel unless multiple CPU cores are available and Go scheduler assigns them accordingly.

Why it matters: Assuming automatic parallelism can lead to performance surprises and incorrect expectations about speedup.

Quick: Can you safely share variables between goroutines without synchronization? Commit to yes or no.

Common Belief: Since goroutines are lightweight, sharing variables between them is safe without locks or channels.

Reality: Sharing variables without synchronization causes race conditions and unpredictable bugs.

Why it matters: Ignoring synchronization leads to hard-to-find errors and unstable programs.

Quick: Does adding more goroutines always make a program faster? Commit to yes or no.

Common Belief: More goroutines always improve program speed by doing more work at once.

Reality: Too many goroutines can cause overhead, contention, and slowdowns if not managed properly.

Why it matters: Blindly increasing goroutines wastes resources and can degrade performance.

Quick: Are channels just another way to share memory? Commit to yes or no.

Common Belief: Channels share memory between goroutines just like variables do.

Reality: Channels transfer copies of data safely, avoiding direct shared memory access.

Why it matters: Misunderstanding channels can cause misuse and concurrency bugs.

Expert Zone

1

Goroutine stacks start very small (a few KB) and grow dynamically, unlike OS threads with fixed large stacks, enabling massive concurrency.

2

The Go scheduler uses a work-stealing algorithm to balance goroutines across OS threads, improving CPU utilization.

3

Channels can be buffered or unbuffered, affecting synchronization behavior and performance subtly.

When NOT to use

Avoid using goroutines for CPU-bound tasks that require true parallelism without synchronization; consider using parallelism with multiple processes or specialized libraries. Also, for simple sequential tasks, concurrency adds unnecessary complexity.

Production Patterns

In real systems, goroutines are used for handling web requests, background jobs, pipelines, and event loops. Patterns like worker pools limit goroutine count to control resource use. Channels coordinate tasks and signal completion, while context.Context manages cancellation and timeouts.

Connections

Operating System Threads

Goroutines are lightweight abstractions built on top of OS threads.

Understanding OS threads helps grasp why goroutines are efficient and how the Go scheduler multiplexes them.

Communicating Sequential Processes (CSP)

Channels in Go implement CSP principles for safe communication.

Knowing CSP theory clarifies why channels avoid shared memory issues and simplify concurrency.

Project Management

Concurrency is like managing multiple tasks or team members working independently but coordinating to finish a project.

Seeing concurrency as task management helps understand synchronization, communication, and avoiding deadlocks.

Common Pitfalls

#1 Starting goroutines without waiting for them to finish causes the program to exit early.

Wrong approach:

go func() {
fmt.Println("Hello from goroutine")
}()
// main ends immediately here

Correct approach:

var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("Hello from goroutine")
}()
wg.Wait()

Root cause:

Not synchronizing main with goroutines leads to premature program exit before goroutines run.

#2 Accessing shared variables from multiple goroutines without synchronization causes race conditions.

Wrong approach:

var counter int
func increment() {
counter++
}
for i := 0; i < 100; i++ {
go increment()
}

Correct approach:

var counter int
var mu sync.Mutex
func increment() {
mu.Lock()
counter++
mu.Unlock()
}
for i := 0; i < 100; i++ {
go increment()
}

Root cause:

Ignoring mutual exclusion when sharing data causes unpredictable results.

#3 Using unbuffered channels without proper synchronization causes deadlocks.

Wrong approach:

ch := make(chan int)
ch <- 1 // blocks forever because no receiver

Correct approach:

ch := make(chan int)
go func() {
fmt.Println(<-ch)
}()
ch <- 1

Root cause:

Unbuffered channels require sender and receiver to be ready simultaneously; missing one causes deadlock.

Key Takeaways

Concurrency lets programs run multiple tasks overlapping in time to improve efficiency and responsiveness.

Goroutines are lightweight threads managed by Go's runtime, enabling thousands of concurrent tasks with low overhead.

Channels provide a safe way for goroutines to communicate and synchronize without sharing memory directly.

Proper synchronization and understanding of goroutine scheduling are essential to avoid bugs like race conditions and deadlocks.

Concurrency is powerful but requires careful design to balance performance, safety, and complexity.