Goroutine lifecycle - Step-by-Step Execution

Concept Flow - Goroutine lifecycle

Start main function

↓

Create goroutine

↓

Goroutine runs concurrently

↓

Goroutine completes task

↓

Main waits or continues

↓

Program ends when main ends

This flow shows how a goroutine starts, runs alongside main, completes, and how the program ends when main finishes.

Execution Sample

Go

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

This code starts a goroutine to print a message while main prints another message concurrently.

Execution Table

Step	Action	Goroutine State	Main State	Output
1	Start main function	Not started	Running
2	Launch goroutine with go keyword	Starting	Running
3	Main prints 'Hello from main'	Running concurrently	Printed message	Hello from main
4	Goroutine prints 'Hello from goroutine'	Printed message	Printed message	Hello from main Hello from goroutine
5	Main function ends	May or may not have finished	Ended	Hello from main Hello from goroutine
6	Program ends	Ended	Ended	Hello from main Hello from goroutine

💡 Program ends when main function finishes, goroutine may finish before or after main ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
Goroutine State	Not started	Starting	Running concurrently	Printed message	Ended
Main State	Running	Running	Printed message	Printed message	Ended

Key Moments - 3 Insights

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

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

Does the goroutine run before or after the main function prints?

They run concurrently, so the order is not guaranteed. The execution_table shows main printing first at step 3, but goroutine could print first in other runs.

What happens if main ends before the goroutine finishes?

The program ends immediately, stopping all goroutines, so the goroutine may not complete its task, as explained in the exit_note.

Visual Quiz - 3 Questions

Look at the execution_table, what is the goroutine state at step 3?

A Ended

B Not started

C Running concurrently

D Starting

💡 Hint

Check the 'Goroutine State' column in row for step 3 in execution_table.

At which step does the main function print its message?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Output' columns in execution_table for when main prints.

If main ends immediately after launching the goroutine, what might happen to the goroutine's output?

A It might not print at all

B It will always print before main ends

C It will print twice

D It will block main from ending

💡 Hint

Refer to the exit_note and key_moments about program ending before goroutine finishes.

Concept Snapshot

Goroutine lifecycle in Go:
- main starts and runs
- 'go' keyword launches goroutine concurrently
- goroutine runs alongside main
- main may finish before goroutine
- program ends when main ends, stopping goroutines
- use sync or channels to wait for goroutines

Full Transcript

This visual trace shows how a goroutine starts when the 'go' keyword is used inside main. The goroutine runs at the same time as main. Both can print messages in any order. The program ends when main finishes, which can stop goroutines if they are not done. This means goroutines may not complete if main ends too soon. To ensure goroutines finish, synchronization methods are needed. The execution table tracks states and outputs step by step.

Practice

1. What does a goroutine in Go allow your program to do?

easy

A. Make the program run slower

B. Automatically fix bugs in the code

C. Prevent the program from exiting

D. Run multiple functions at the same time

Solution

1. Step 1: Understand goroutine purpose

   A goroutine lets your program run functions concurrently, meaning at the same time.

2. Step 2: Compare options

   Only Run multiple functions at the same time correctly describes this behavior. Other options are incorrect or unrelated.

3. Final Answer:

   Run multiple functions at the same time -> Option D

4. Quick Check:

   Goroutine = concurrent execution [OK]

Hint: Goroutines run functions concurrently, like multitasking [OK]

Common Mistakes:

• Thinking goroutines slow down the program
• Believing goroutines prevent program exit automatically
• Assuming goroutines fix code errors

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

easy

A. goroutine doWork()

B. go doWork()

C. start doWork()

D. run go doWork()

Solution

1. Step 1: Recall goroutine syntax

   In Go, prefixing a function call with go starts it as a goroutine.

2. Step 2: Check options

   Only go doWork() uses the correct syntax: go doWork(). Others are invalid.

3. Final Answer:

   go doWork() -> Option B

4. Quick Check:

   Start goroutine = go + function call [OK]

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

Common Mistakes:

• Using keywords like 'start' or 'run' instead of 'go'
• Writing 'goroutine' as a keyword
• Adding extra words before 'go'

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

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

medium

A. Main function finished

B. Hello from goroutine\nMain function finished

C. Main function finished\nHello from goroutine

D. No output

Solution

1. Step 1: Understand goroutine and main flow

   The goroutine runs sayHello() concurrently, printing "Hello from goroutine". The main function prints "Main function finished" immediately.

2. Step 2: Consider the sleep delay

   The time.Sleep pauses main to allow goroutine to run before program exits, so both prints appear.

3. Final Answer:

   Main function finished Hello from goroutine -> Option C

4. Quick Check:

   Sleep allows goroutine output after main print [OK]

Hint: Sleep main to let goroutine print before exit [OK]

Common Mistakes:

• Ignoring sleep causes goroutine output to miss
• Assuming goroutine prints before main
• Expecting no output without sleep

4. Identify the problem in this Go code snippet:

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

medium

A. The goroutine will never run because main exits immediately

B. Syntax error in anonymous function

C. Missing import for goroutine package

D. No problem, code runs fine

Solution

1. Step 1: Analyze goroutine lifecycle

   The main function starts a goroutine but then immediately exits, ending the program.

2. Step 2: Effect on goroutine execution

   Because main exits, the goroutine may not get time to run, so "Inside goroutine" might never print.

3. Final Answer:

   The goroutine will never run because main exits immediately -> Option A

4. Quick Check:

   Main exit stops goroutine early [OK]

Hint: Main must wait or goroutine may not run [OK]

Common Mistakes:

• Thinking goroutine runs after main exits
• Assuming syntax error in anonymous function
• Believing a special import is needed

5. You want to start 3 goroutines that each print their number (1, 2, 3). Which code correctly ensures each goroutine prints its own number without race conditions?

package main
import (
  "fmt"
  "time"
)
func main() {
  for i := 1; i <= 3; i++ {
    // Which option below is correct here?
  }
  time.Sleep(100 * time.Millisecond)
}

hard

A. go func(n int) { fmt.Println(n) }(i)

B. go func() { fmt.Println(i) }(i)

C. go func() { fmt.Println(i) }()

D. go func(n int) { fmt.Println(i) }(i)

Solution

1. Step 1: Understand variable capture in goroutines

   Loop variable i changes during iterations; capturing it directly in goroutine causes all to print last value.

2. Step 2: Use parameter to pass current value

   Passing i as a parameter n to the goroutine fixes this, so each prints its own number.

3. Final Answer:

   go func(n int) { fmt.Println(n) }(i) -> Option A

4. Quick Check:

   Pass loop variable as parameter to goroutine [OK]

Hint: Pass loop variable as function parameter to avoid capture issues [OK]

Common Mistakes:

• Capturing loop variable directly causing all prints same value
• Passing wrong variable to goroutine
• Confusing parameter and captured variable