Goroutines and Concurrency

# CHAPTER 19

Goroutines and Concurrency #

1. Introduction #

In languages like Java or C++, you create OS Threads to achieve this, which are heavy, memory-intensive, and hard to manage. Go was built from the ground up to solve this. Go uses Goroutines—incredibly lightweight, virtual threads that make writing concurrent code effortless.

2. Learning Objectives #

• Understand Concurrency vs. Parallelism.

• Spawn a Goroutine using the go keyword.

• Understand how the Go Scheduler manages execution.

• Recognize the problem of the main function exiting too early.

• Use time.Sleep as a basic synchronization method.

3. Concurrency vs Parallelism #

• Concurrency: Dealing with many things at once (e.g., A chef chopping onions, then stirring soup, then going back to onions).

• Parallelism: Doing many things at exactly the same time (e.g., Two chefs: one chops onions, the other stirs soup).

Go excels at Concurrency. By breaking tasks into Goroutines, the Go runtime automatically distributes them across all available CPU cores, naturally achieving Parallelism!

4. What is a Goroutine? #

• An OS Thread takes about 1MB of memory. You can only run a few thousand before crashing your server.

• A Goroutine takes only 2KB of memory. You can easily run 100,000 Goroutines on a standard laptop simultaneously!

5. Spawning a Goroutine #

Let's look at sequential code first:

package main
import (
    "fmt"
    "time"
)

func count(name string) {
    for i := 1; i <= 3; i++ {
        fmt.Println(name, ":", i)
        time.Sleep(time.Millisecond * 500) // Pause for half a second
    }
}

func main() {
    count("Sheep")
    count("Cows") 
    // It takes 3 seconds total. Sheep finishes, THEN Cows start.
}

Now, let's make it Concurrent!

func main() {
    go count("Sheep") // Spawns a Goroutine and instantly moves to the next line!
    go count("Cows")  // Spawns another Goroutine!
    
    // We MUST pause the main function, otherwise it will exit instantly and kill the Goroutines!
    time.Sleep(time.Second * 2) 
    fmt.Println("Done!")
}

*Output:*

Cows : 1
Sheep : 1
Sheep : 2
Cows : 2
Cows : 3
Sheep : 3
Done!

Notice how they print at the exact same time!

6. The "Main" Goroutine Rule #

This is why we had to add time.Sleep in the example above. If we didn't, main would spawn the two tasks and immediately close the program before the sheep or cows had a chance to print anything!

7. Visualizing the Goroutine Flow #

Main Goroutine starts
      |
      +---- `go count("Sheep")` spawns Goroutine 1 ---(Executes independently)--->
      |
      +---- `go count("Cows")` spawns Goroutine 2 ---(Executes independently)--->
      |
Main Goroutine waits (time.Sleep)
      |
Main Goroutine finishes -> Program Exits (Kills any surviving Goroutines)

8. The Go Scheduler #

9. Common Mistakes #

• Forgetting to Wait: Using the go keyword but wondering why the program finishes instantly without printing any output. (The main function finished too fast).

• Using time.Sleep in Production: time.Sleep is great for tutorials, but in the real world, you never know exactly how long a database query or network request will take. Sleeping for an arbitrary amount of time is terrible practice. (We will learn the proper way to wait using WaitGroups and Channels in the next chapters).

10. Best Practices #

• Keep it Lightweight: Feel free to spawn thousands of Goroutines! Go is specifically designed to handle them. For example, a Go web server automatically spawns a brand new Goroutine for every single incoming HTTP request.

11. Exercises #

1. 1. Write a function printNumbers() that prints 1 to 5 with a 100ms sleep.

1. 2. Write a function printLetters() that prints A to E with a 100ms sleep.

1. 3. Call both in main() using the go keyword, and add a sleep in main to ensure they finish. Observe the interleaved output.

12. MCQs with Answers & Explanations #

13. Interview Preparation #

1. 1. Contrast Goroutines with traditional OS Threads (Memory footprint, management).

1. 2. What happens if a Goroutine is running, but the main Goroutine exits?

1. 3. Explain the difference between Concurrency and Parallelism.

14. Summary #

15. Next Chapter Recommendation #