Why concurrency is needed in Go - Why It Works This Way

Overview - Why concurrency is needed

What is it?

Concurrency means doing many things at the same time or overlapping in time. It lets a program handle multiple tasks without waiting for one to finish before starting another. This is useful when tasks take time, like waiting for files or network responses. Concurrency helps programs run faster and stay responsive.

Why it matters

Without concurrency, programs would do one thing at a time and wait for slow tasks to finish, making users wait and wasting computer power. Concurrency lets computers use their multiple cores and handle many tasks smoothly, like loading a webpage while downloading a file. It makes software faster, more efficient, and better at handling real-world problems.

Where it fits

Before learning concurrency, you should understand basic programming concepts like functions, loops, and variables. After concurrency, you can learn about parallelism, synchronization, and advanced topics like distributed systems or asynchronous programming.

Mental Model

Core Idea

Concurrency is about managing multiple tasks at once so a program can do more without waiting.

Think of it like...

Imagine a chef in a kitchen cooking several dishes at the same time by starting one, then while it cooks, starting another, and so on, instead of waiting for each dish to finish before starting the next.

┌───────────────┐
│   Task 1      │
│  (start)     │
│      ┌─────┐  │
│      │wait │  │
│      └─────┘  │
│   Task 2      │
│  (start)     │
│      ┌─────┐  │
│      │wait │  │
│      └─────┘  │
│   Task 3      │
│  (start)     │
│      ┌─────┐  │
│      │wait │  │
│      └─────┘  │
└───────────────┘
Tasks overlap during waiting times instead of running one after another.

Build-Up - 6 Steps

1

Foundation

Understanding sequential execution

Concept: Programs run instructions one after another by default.

In Go, if you write code to do Task A then Task B, the program finishes Task A completely before starting Task B. For example: package main import "fmt" func main() { fmt.Println("Task A start") // simulate work fmt.Println("Task A done") fmt.Println("Task B start") fmt.Println("Task B done") } This runs tasks one by one.

Result

Output: Task A start Task A done Task B start Task B done

Understanding sequential execution shows why programs can be slow if tasks wait for each other.

2

Foundation

What causes waiting in programs

Concept: Some tasks take time because they wait for external things like files or networks.

Imagine a program that reads a file or waits for a website to respond. These actions take time, and the program must wait before continuing. For example, reading a file might take seconds, during which the program does nothing else.

Result

The program pauses during waiting, making the user wait too.

Knowing what causes waiting helps understand why concurrency can improve speed and responsiveness.

3

Intermediate

Introducing goroutines for concurrency

🤔Before reading on: do you think starting multiple goroutines runs tasks truly at the same time or just switches between them quickly? Commit to your answer.

Concept: Go uses goroutines to run many tasks concurrently, letting the program handle multiple things without waiting for each to finish.

A goroutine is a lightweight thread managed by Go. You start one by adding 'go' before a function call: package main import ( "fmt" "time" ) func task(name string) { fmt.Println(name, "start") time.Sleep(2 * time.Second) // simulate work fmt.Println(name, "done") } func main() { go task("Task A") go task("Task B") time.Sleep(3 * time.Second) // wait for goroutines to finish } This runs Task A and Task B concurrently.

Result

Output order may vary: Task A start Task B start Task A done Task B done

Understanding goroutines unlocks how Go handles concurrency simply and efficiently.

4

Intermediate

Concurrency improves responsiveness

🤔Before reading on: do you think concurrency only makes programs faster or also makes them more responsive to users? Commit to your answer.

Concept: Concurrency lets programs stay responsive by doing slow tasks in the background while continuing other work.

Imagine a program downloading a file and showing progress. Without concurrency, the program waits for the download to finish before updating the screen. With concurrency, the download runs in a goroutine, and the main program can update the screen or respond to user input. Example: package main import ( "fmt" "time" ) func download() { for i := 1; i <= 5; i++ { time.Sleep(1 * time.Second) fmt.Println("Downloaded", i*20, "%") } } func main() { go download() for i := 0; i < 5; i++ { fmt.Println("Main program working") time.Sleep(700 * time.Millisecond) } time.Sleep(2 * time.Second) // wait for download } This shows both tasks happening together.

Result

Output interleaves: Main program working Downloaded 20 % Main program working Downloaded 40 % ...

Knowing concurrency improves responsiveness helps design better user experiences.

5

Advanced

Concurrency vs parallelism difference

🤔Before reading on: do you think concurrency always means tasks run at the exact same time? Commit to your answer.

Concept: Concurrency means managing multiple tasks at once, but parallelism means running them exactly at the same time on multiple processors.

Go schedules goroutines on available CPU cores. If you have one core, goroutines run by switching quickly (concurrency). If you have multiple cores, goroutines can run truly in parallel. Example: package main import ( "fmt" "runtime" ) func main() { fmt.Println("CPU cores:", runtime.NumCPU()) } This tells how many cores your computer has.

Result

Output example: CPU cores: 4

Understanding concurrency vs parallelism clarifies what Go does behind the scenes and sets realistic expectations.

6

Expert

Why concurrency is key in modern computing

🤔Before reading on: do you think concurrency is only about speed, or does it also help with resource use and program design? Commit to your answer.

Concept: Concurrency is essential for efficient resource use, scalability, and building complex systems that handle many tasks smoothly.

Modern computers have multiple cores and many programs run on networks or handle many users. Concurrency lets programs use CPU cores well, avoid wasting time waiting, and handle many tasks like web servers or databases efficiently. Go's concurrency model with goroutines and channels makes writing such programs easier and less error-prone. Without concurrency, programs would be slow, unresponsive, and unable to scale to many users or tasks.

Result

Real-world systems like web servers handle thousands of requests concurrently using concurrency.

Knowing concurrency's role in resource use and scalability helps appreciate why it's a foundation of modern software.

Under the Hood

Go uses a scheduler inside its runtime to manage goroutines. Goroutines are very lightweight compared to OS threads. The scheduler multiplexes many goroutines onto fewer OS threads, switching between them when they wait or yield. This lets thousands of goroutines run efficiently without heavy system overhead.

Why designed this way?

Go was designed to make concurrency easy and efficient for developers. Traditional threads are heavy and complex to manage. Goroutines and the scheduler provide a simpler, faster way to write concurrent programs without deep OS knowledge or complex synchronization.

┌───────────────┐
│   Goroutine 1 │
├───────────────┤
│   Goroutine 2 │
├───────────────┤
│   Goroutine 3 │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Scheduler    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  OS Threads   │
│  (few in num) │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does starting a goroutine guarantee it runs immediately on a separate CPU core? Commit to yes or no.

Common Belief: Starting a goroutine means the task runs instantly and in parallel on a separate CPU core.

Reality: Goroutines are scheduled by Go's runtime and may run concurrently but not necessarily in parallel immediately. They share OS threads and CPU cores based on availability.

Why it matters: Assuming immediate parallelism can lead to wrong performance expectations and debugging confusion.

Quick: Do you think concurrency always makes programs faster? Commit to yes or no.

Common Belief: Using concurrency always speeds up a program.

Reality: Concurrency can improve responsiveness but may not always speed up execution due to overhead or resource contention.

Why it matters: Misusing concurrency can cause slower programs or bugs, wasting effort and resources.

Quick: Is concurrency only useful for CPU-heavy tasks? Commit to yes or no.

Common Belief: Concurrency is mainly for speeding up CPU-intensive work.

Reality: Concurrency is especially useful for I/O-bound tasks like waiting for files or networks, improving efficiency by not blocking.

Why it matters: Ignoring concurrency for I/O tasks misses big performance gains and better user experience.

Quick: Does concurrency mean the same as parallelism? Commit to yes or no.

Common Belief: Concurrency and parallelism are the same thing.

Reality: Concurrency is about managing multiple tasks at once; parallelism is about running them simultaneously on multiple processors.

Why it matters: Confusing these leads to misunderstanding program behavior and hardware use.

Expert Zone

1

Goroutines are multiplexed onto a small number of OS threads, which means thousands of goroutines can run with minimal memory overhead.

2

The Go scheduler uses work-stealing to balance goroutines across threads, improving CPU utilization without programmer intervention.

3

Channels in Go provide a safe way to communicate between goroutines, avoiding many common concurrency bugs like race conditions.

When NOT to use

Concurrency is not ideal for simple, quick tasks where overhead outweighs benefits. For heavy CPU-bound tasks, parallelism with multiple cores or specialized libraries may be better. Also, for real-time systems with strict timing, concurrency must be carefully managed or avoided.

Production Patterns

In production, concurrency is used in web servers to handle many user requests simultaneously, in pipelines to process data streams efficiently, and in microservices to manage asynchronous communication. Go's goroutines and channels are central to these patterns.

Connections

Operating System Threads

Concurrency in Go builds on OS threads but manages them more efficiently.

Understanding OS threads helps grasp why goroutines are lightweight and how Go's scheduler improves performance.

Asynchronous Programming

Concurrency is a broader concept that includes asynchronous programming as a way to handle waiting tasks without blocking.

Knowing concurrency clarifies how async/await patterns in other languages relate to goroutines and channels.

Human Multitasking

Concurrency in programming is similar to how humans switch attention between tasks to stay productive.

Recognizing this connection helps understand why concurrency improves responsiveness but not always speed.

Common Pitfalls

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

Wrong approach:

package main
import "fmt"
func task() {
fmt.Println("Task running")
}
func main() {
go task()
// no wait here
}

Correct approach:

package main
import (
"fmt"
"time"
)
func task() {
fmt.Println("Task running")
}
func main() {
go task()
time.Sleep(1 * time.Second) // wait for goroutine
}

Root cause:

Not understanding that goroutines run asynchronously and main may exit before they complete.

#2 Sharing data between goroutines without synchronization causes race conditions.

Wrong approach:

package main
import (
"fmt"
"time"
)
var counter = 0
func increment() {
counter = counter + 1
}
func main() {
go increment()
go increment()
time.Sleep(1 * time.Second)
fmt.Println(counter)
}

Correct approach:

package main
import (
"fmt"
"sync"
"time"
)
var counter = 0
var mu sync.Mutex
func increment() {
mu.Lock()
counter = counter + 1
mu.Unlock()
}
func main() {
go increment()
go increment()
time.Sleep(1 * time.Second)
fmt.Println(counter)
}

Root cause:

Not using synchronization primitives to protect shared data in concurrent code.

Key Takeaways

Concurrency lets programs handle multiple tasks at once, improving speed and responsiveness.

Go uses goroutines as lightweight threads to make concurrency easy and efficient.

Concurrency is about managing tasks overlapping in time, not always running simultaneously.

Proper synchronization is essential to avoid bugs when sharing data between concurrent tasks.

Concurrency is a foundation for modern software that needs to be fast, scalable, and responsive.

Practice

1. Why do we need concurrency in Go programs?

easy

A. To simplify the code by removing all loops and conditions.

B. To allow multiple tasks to run at the same time, improving speed and responsiveness.

C. To make the program use less memory by running tasks one after another.

D. To avoid using functions and write everything in the main block.

Solution

1. Step 1: Understand concurrency purpose

   Concurrency allows a program to handle multiple tasks at once instead of waiting for one to finish before starting another.

2. Step 2: Relate concurrency to Go

   Go uses goroutines to run tasks concurrently, which helps programs be faster and more responsive.

3. Final Answer:

   To allow multiple tasks to run at the same time, improving speed and responsiveness. -> Option B

4. Quick Check:

   Concurrency = multiple tasks at once [OK]

Hint: Concurrency means doing many things at once [OK]

Common Mistakes:

• Thinking concurrency reduces memory by running tasks sequentially
• Confusing concurrency with simpler code structure
• Believing concurrency removes the need for functions

2. Which of the following is the correct way to start a goroutine in Go?

easy

A. go myFunction()

B. start myFunction()

C. run myFunction()

D. goroutine myFunction()

Solution

1. Step 1: Recall Go syntax for goroutines

   In Go, the keyword go is used before a function call to start it as a goroutine.

2. Step 2: Check each option

   Only go myFunction() uses the correct go keyword syntax; others are invalid in Go.

3. Final Answer:

   go myFunction() -> Option A

4. Quick Check:

   Start goroutine with 'go' keyword [OK]

Hint: Use 'go' before function to start goroutine [OK]

Common Mistakes:

• Using 'start' or 'run' instead of 'go'
• Forgetting the 'go' keyword before function call
• Trying to declare goroutine with 'goroutine' keyword

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

package main
import (
  "fmt"
  "time"
)
func sayHello() {
  fmt.Println("Hello")
}
func main() {
  go sayHello()
  time.Sleep(1 * time.Second)
  fmt.Println("World")
}

medium

A. World\nHello

B. Hello

C. Hello\nWorld

D. World

Solution

1. Step 1: Understand goroutine and sleep

   The function sayHello runs as a goroutine, so it runs concurrently with main. The main function sleeps 1 second to allow sayHello to print.

2. Step 2: Determine print order

   Because of the sleep, "Hello" prints first from the goroutine, then "World" prints after sleep ends.

3. Final Answer:

   Hello World -> Option C

4. Quick Check:

   Goroutine prints 'Hello' before main prints 'World' [OK]

Hint: Sleep lets goroutine finish before main prints [OK]

Common Mistakes:

• Ignoring time.Sleep and missing 'Hello' output
• Assuming 'World' prints before 'Hello'
• Thinking goroutine blocks main function

4. Identify the problem in this Go code snippet:

package main
import "fmt"
func main() {
  go func() {
    fmt.Println("Running")
  }()
  fmt.Println("Done")
}

medium

A. Goroutines cannot be used inside main function.

B. The anonymous function syntax is incorrect.

C. The fmt package is not imported properly.

D. The program may exit before the goroutine runs, so "Running" might not print.

Solution

1. Step 1: Analyze goroutine execution timing

   The goroutine runs concurrently, but main may finish and exit before the goroutine prints "Running".

2. Step 2: Check code correctness

   The anonymous function syntax and imports are correct; goroutines can run inside main.

3. Final Answer:

   The program may exit before the goroutine runs, so "Running" might not print. -> Option D

4. Quick Check:

   Program exit can stop goroutine early [OK]

Hint: Main may exit before goroutine finishes [OK]

Common Mistakes:

• Thinking anonymous function syntax is wrong
• Believing goroutines can't run in main
• Ignoring program exit timing

5. You want to download 3 files concurrently in Go and print "All done" only after all downloads finish. Which approach correctly uses concurrency to achieve this?

hard

A. Start 3 goroutines for downloads and use a sync.WaitGroup to wait for all to finish before printing "All done".

B. Call the download functions one after another without goroutines, then print "All done".

C. Start 3 goroutines but print "All done" immediately after starting them without waiting.

D. Use a for loop to start downloads but do not synchronize; rely on time.Sleep to wait.

Solution

1. Step 1: Understand concurrency with synchronization

   Starting goroutines runs downloads concurrently, but we must wait for all to finish before printing "All done".

2. Step 2: Use sync.WaitGroup for waiting

   sync.WaitGroup lets main wait until all goroutines complete, ensuring correct order.

3. Final Answer:

   Start 3 goroutines for downloads and use a sync.WaitGroup to wait for all to finish before printing "All done". -> Option A

4. Quick Check:

   WaitGroup synchronizes goroutines before final print [OK]

Hint: Use WaitGroup to wait for all goroutines [OK]

Common Mistakes:

• Not waiting for goroutines before printing
• Using sleep instead of proper synchronization
• Running downloads sequentially without concurrency