Concurrent execution model in Go - Step-by-Step Execution

Concept Flow - Concurrent execution model

Start main function

↓

Launch goroutine

↓

Main continues

↓

Goroutine runs concurrently

↓

Both finish independently

↓

Program ends

Shows how the main function starts, launches a goroutine that runs concurrently, and both run independently until completion.

Execution Sample

Go

package main
import "fmt"
func main() {
  go fmt.Println("Hello from goroutine")
  fmt.Println("Hello from main")
}

This Go program runs two print statements concurrently: one in a goroutine and one in the main function.

Execution Table

Step	Action	Goroutine State	Main State	Output
1	Start main function	Not started	Running
2	Launch goroutine with go keyword	Started (concurrent)	Running
3	Main prints "Hello from main"	Running concurrently	Printed "Hello from main"	Hello from main
4	Goroutine prints "Hello from goroutine"	Printed "Hello from goroutine"	Running	Hello from goroutine
5	Main function ends	May still be running or finished	Ended
6	Program ends when main exits	Ends if not finished	Ends

💡 Program ends when main function finishes, goroutine may or may not finish if main exits too early.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
main	Running	Running	Printed output	Printed output	Ended
goroutine	Not started	Started	Running	Printed output	May end or still running

Key Moments - 3 Insights

Why might the goroutine's output not appear before the program ends?

Because the main function can finish and exit the program before the goroutine runs or completes, as shown in step 6 of the execution_table.

Does the goroutine block the main function from continuing?

No, the goroutine runs concurrently and does not block main, so main continues immediately after launching the goroutine (step 3).

How do we know the goroutine started?

At step 2, the goroutine is launched with the go keyword, changing its state from 'Not started' to 'Started (concurrent)' in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after step 3?

A No output yet

B "Hello from main"

C "Hello from goroutine"

D Both outputs printed

💡 Hint

Check the Output column at step 3 in the execution_table.

At which step does the goroutine print its message?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the Output and Goroutine State columns in the execution_table.

If the main function ends immediately after launching the goroutine, what might happen?

A Goroutine output always appears

B Program waits for goroutine to finish

C Goroutine may not run or finish before program ends

D Main function blocks until goroutine finishes

💡 Hint

Refer to the exit_note and step 6 in the execution_table.

Concept Snapshot

Go's concurrent execution model uses goroutines.
Use 'go' keyword to start a goroutine.
Goroutines run independently and concurrently.
Main function does not wait for goroutines by default.
Program ends when main finishes, possibly before goroutines.
Use synchronization to wait for goroutines if needed.

Full Transcript

This example shows how Go runs code concurrently using goroutines. The main function starts and launches a goroutine with the 'go' keyword. Both the main function and the goroutine run at the same time. The main function prints its message and continues. The goroutine prints its message independently. The program ends when the main function finishes, which might happen before the goroutine completes. This means the goroutine's output might not always appear if the main function exits too soon. Goroutines do not block the main function. To ensure goroutines finish, synchronization methods are needed.

Practice

1. What is a goroutine in Go's concurrent execution model?

easy

A. A lightweight thread managed by the Go runtime

B. A type of variable used for synchronization

C. A special function that runs only once

D. A package for handling errors

Solution

1. Step 1: Understand goroutine concept

   A goroutine is a function or method that runs concurrently with other goroutines.

2. Step 2: Identify goroutine characteristics

   It is lightweight and managed by Go's runtime, unlike OS threads which are heavier.

3. Final Answer:

   A lightweight thread managed by the Go runtime -> Option A

4. Quick Check:

   Goroutine = lightweight thread [OK]

Hint: Goroutine = lightweight thread in Go [OK]

Common Mistakes:

• Confusing goroutine with OS thread
• Thinking goroutine is a variable type
• Assuming goroutine runs only once

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

easy

A. go doWork()

B. goroutine doWork()

C. start doWork()

D. run doWork()

Solution

1. Step 1: Recall goroutine syntax

   In Go, to start a goroutine, prefix the function call with the keyword go.

2. Step 2: Match syntax with options

   Only go doWork() uses the correct keyword and syntax.

3. Final Answer:

   go doWork() -> Option A

4. Quick Check:

   Start goroutine with 'go' keyword [OK]

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

Common Mistakes:

• Using 'goroutine' keyword instead of 'go'
• Using 'start' or 'run' which are invalid
• Omitting the 'go' keyword

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

package main
import (
  "fmt"
  "time"
)
func main() {
  go fmt.Println("Hello from goroutine")
  fmt.Println("Hello from main")
  time.Sleep(100 * time.Millisecond)
}

medium

A. No output

B. Hello from goroutine\nHello from main

C. Hello from main

D. Hello from main\nHello from goroutine

Solution

1. Step 1: Understand goroutine and main execution

   The goroutine prints "Hello from goroutine" concurrently, while main prints "Hello from main" immediately.

2. Step 2: Analyze timing with Sleep

   The time.Sleep allows the goroutine time to run before the program exits, so both lines print.

3. Final Answer:

   Hello from main\nHello from goroutine -> Option D

4. Quick Check:

   Sleep allows goroutine output after main [OK]

Hint: Sleep lets goroutine finish before program ends [OK]

Common Mistakes:

• Ignoring need for sleep to let goroutine run
• Assuming goroutine output always prints first
• Expecting no output due to race condition

4. Identify the error in this Go code snippet that tries to run a goroutine:

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

medium

A. Missing import of time package

B. Program exits before goroutine runs

C. Syntax error in anonymous function

D. Cannot use go with anonymous functions

Solution

1. Step 1: Check syntax correctness

   The anonymous function syntax and goroutine start are correct; no syntax errors.

2. Step 2: Analyze program flow

   The main function exits immediately after starting the goroutine, so "Running" may never print.

3. Final Answer:

   Program exits before goroutine runs -> Option B

4. Quick Check:

   Program ends before goroutine runs [OK]

Hint: Add sleep or sync to wait for goroutine [OK]

Common Mistakes:

• Thinking syntax is wrong for anonymous goroutine
• Forgetting program ends immediately
• Assuming goroutine blocks main automatically

5. You want to run 3 goroutines that each print their number (1, 2, 3). Which code correctly prints all numbers reliably before the program exits?

package main
import (
  "fmt"
  "sync"
)
func main() {
  var wg sync.WaitGroup
  for i := 1; i <= 3; i++ {
    wg.Add(1)
    go func(n int) {
      defer wg.Done()
      fmt.Println(n)
    }(i)
  }
  // What should be here?
}

hard

A. wg.Done()

B. time.Sleep(1 * time.Second)

C. wg.Wait()

D. close(wg)

Solution

1. Step 1: Understand WaitGroup usage

   WaitGroup tracks goroutines; wg.Add(1) before start, wg.Done() after done.

2. Step 2: Ensure main waits for all goroutines

   Calling wg.Wait() blocks main until all goroutines call Done().

3. Final Answer:

   wg.Wait() -> Option C

4. Quick Check:

   WaitGroup.Wait() waits for goroutines [OK]

Hint: Use wg.Wait() to wait all goroutines finish [OK]

Common Mistakes:

• Using Sleep instead of WaitGroup for sync
• Trying to close WaitGroup (not allowed)
• Calling Done() in main instead of goroutine