Goroutine creation - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of simple goroutine execution

What is the output of this Go program?

Go

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

A

Hello from goroutine
Main function finished

B

Main function finished
Hello from goroutine

C Hello from goroutine

D Main function finished

💡 Hint

Think about how goroutines run concurrently and why we use Sleep here.

The goroutine prints first, but since goroutines run concurrently, the main function waits 100ms to let it finish before printing its own message.

❓ Predict Output

intermediate

Goroutine variable capture behavior

What will be printed by this Go program?

Go

package main
import (
	"fmt"
	"time"
)
func main() {
	for i := 0; i < 3; i++ {
		go func() {
			fmt.Println(i)
		}()
	}
	time.Sleep(100 * time.Millisecond)
}

A

3
3
3

B

0
1
2

C

0
0
0

D

2
2
2

💡 Hint

Consider how the loop variable is captured by the goroutine function.

The anonymous function captures the variable i by reference, so when the goroutines run, i has already reached 3.

🔧 Debug

advanced

Identify the error in goroutine creation

What error will this Go program produce when run?

Go

package main
func main() {
	go func() {
		println("Running")
	}()
}

A Runtime panic: goroutine not started

B Syntax error: missing import fmt

C Deadlock detected

D No output, program exits immediately

💡 Hint

Think about what happens to the main function after starting a goroutine.

The main function exits immediately after starting the goroutine, so the goroutine may not run before program exit.

❓ Predict Output

advanced

Goroutine with argument capture

What is the output of this Go program?

Go

package main
import (
	"fmt"
	"time"
)
func main() {
	for i := 0; i < 3; i++ {
		go func(n int) {
			fmt.Println(n)
		}(i)
	}
	time.Sleep(100 * time.Millisecond)
}

A

2
2
2

B

3
3
3

C

0
1
2

D

0
0
0

💡 Hint

Look at how the loop variable is passed as an argument to the goroutine function.

Passing i as an argument copies its value at each iteration, so each goroutine prints its own value.

🧠 Conceptual

expert

Goroutine scheduling and output order

Given this Go program, which output is guaranteed?

Go

package main
import (
	"fmt"
	"sync"
)
func main() {
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		defer wg.Done()
		fmt.Println("First")
	}()
	go func() {
		defer wg.Done()
		fmt.Println("Second")
	}()
	wg.Wait()
}

A

First
Second

B Either "First\nSecond" or "Second\nFirst"

C

Second
First

D No output

💡 Hint

Consider how goroutines are scheduled and the use of WaitGroup.

The WaitGroup ensures both goroutines finish before main exits, but their print order is not guaranteed.

Practice

1. What does adding go before a function call do in Go?

easy

A. Starts the function as a new goroutine running concurrently

B. Delays the function call until later

C. Runs the function only if a condition is true

D. Converts the function into a method

Solution

1. Step 1: Understand the role of go keyword

   The go keyword in Go is used to start a new goroutine, which is a lightweight thread that runs concurrently with other goroutines.

2. Step 2: Identify what happens when go is used before a function call

   When go is placed before a function call, that function runs asynchronously, allowing the program to continue without waiting for it to finish.

3. Final Answer:

   Starts the function as a new goroutine running concurrently -> Option A

4. Quick Check:

   go starts concurrent execution [OK]

Hint: Remember: 'go' runs function concurrently [OK]

Common Mistakes:

• Thinking 'go' delays function execution
• Confusing goroutine with method conversion
• Assuming 'go' runs function conditionally

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

easy

A. run go doWork()

B. go doWork()

C. start doWork()

D. goroutine doWork()

Solution

1. Step 1: Recall the syntax for starting a goroutine

   In Go, to start a goroutine, you simply write go followed by the function call without parentheses or extra keywords.

2. Step 2: Match the correct syntax

   go doWork() uses go doWork(), which is the exact syntax to start a goroutine. Other options use invalid keywords or extra words.

3. Final Answer:

   go doWork() -> Option B

4. Quick Check:

   Correct goroutine syntax = go function() [OK]

Hint: Use 'go' directly before function call [OK]

Common Mistakes:

• Adding extra keywords like 'start' or 'run'
• Writing 'goroutine' instead of 'go'
• Missing parentheses after function name

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("Hello from main")
  time.Sleep(100 * time.Millisecond)
}

medium

A. Hello from main\nHello from goroutine

B. Hello from goroutine\nHello from main

C. Hello from main only

D. No output

Solution

1. Step 1: Understand goroutine and main execution order

   The sayHello function runs as a goroutine, so it runs concurrently with the main function. The main function prints first, then sleeps to allow the goroutine to run.

2. Step 2: Analyze output order

   Main prints "Hello from main" immediately. The goroutine prints "Hello from goroutine" during the sleep period, so both lines appear with main's message first.

3. Final Answer:

   Hello from main Hello from goroutine -> Option A

4. Quick Check:

   main prints first, goroutine runs during sleep [OK]

Hint: Sleep to let goroutine print after main [OK]

Common Mistakes:

• Assuming goroutine always prints first
• Forgetting to add sleep to wait for goroutine
• Expecting no output because goroutine is async

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

func printNumber(n int) {
  fmt.Println(n)
}

func main() {
  go printNumber
}

medium

A. Goroutines cannot take parameters

B. Function printNumber cannot be used as goroutine

C. Missing parentheses after function name in goroutine call

D. Missing import of fmt package

Solution

1. Step 1: Check goroutine syntax for function calls

   When starting a goroutine, the function must be called with parentheses, even if it has parameters. Here, go printNumber misses parentheses and argument.

2. Step 2: Identify the specific syntax error

   The code should be go printNumber(5) or some integer argument with parentheses to call the function properly as a goroutine.

3. Final Answer:

   Missing parentheses after function name in goroutine call -> Option C

4. Quick Check:

   Function call needs parentheses [OK]

Hint: Always use parentheses with goroutine function calls [OK]

Common Mistakes:

• Omitting parentheses when calling function as goroutine
• Thinking goroutines can't have parameters
• Ignoring missing imports causing unrelated errors

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 all printing 4?

for i := 1; i <= 3; i++ {
  go func() {
    fmt.Println(i)
  }()
}

hard

A. Add time.Sleep inside the loop after starting goroutine

B. Use global variable instead of loop variable

C. Remove the anonymous function and call go fmt.Println(i)

D. Pass i as parameter to anonymous function: go func(n int) { fmt.Println(n) }(i)

Solution

1. Step 1: Understand closure capturing loop variable

   The anonymous function captures the variable i by reference, so all goroutines print the final value (4) after the loop ends.

2. Step 2: Fix by passing loop variable as parameter

   Passing i as a parameter to the anonymous function creates a new local copy for each goroutine, preserving the correct value.

3. Final Answer:

   Pass i as parameter to anonymous function: go func(n int) { fmt.Println(n) }(i) -> Option D

4. Quick Check:

   Pass loop variable as argument to fix closure [OK]

Hint: Pass loop variable as argument to goroutine function [OK]

Common Mistakes:

• Not passing loop variable, causing all goroutines to print same value
• Using global variables instead of parameters
• Relying on sleep to fix output order