Goroutine lifecycle - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Goroutine execution order

What is the output of this Go program?

Go

package main

import (
	"fmt"
	"time"
)

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

A Hello from main\nHello from goroutine

B Hello from goroutine\nHello from main

C Hello from main

D No output (program exits immediately)

💡 Hint

Remember that goroutines run concurrently and main may finish before they print unless you wait.

The main function prints first, then the goroutine prints after. The Sleep allows the goroutine to run before the program exits.

❓ Predict Output

intermediate

Goroutine variable capture

What will be printed by this Go program?

Go

package main

import (
	"fmt"
	"time"
)

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

A 0\n0\n0

B 3\n3\n3

C Compilation error

D 0\n1\n2

💡 Hint

Think about how the loop variable is captured by the goroutine's closure.

Passing the loop variable as a parameter to the goroutine captures its value at each iteration, so the goroutines print 0, 1, and 2 respectively.

🔧 Debug

advanced

Detecting goroutine leak

What problem does this Go code cause?

Go

package main

import (
	"fmt"
	"time"
)

func worker(ch chan int) {
	for {
		val, ok := <-ch
		if !ok {
			return
		}
		fmt.Println(val)
	}
}

func main() {
	ch := make(chan int)
	go worker(ch)
	ch <- 1
	ch <- 2
	// Missing close(ch)
	select {}
}

A The program deadlocks because the channel is never closed and worker waits forever.

B The program prints 1 and 2 and exits cleanly.

C Compilation error due to missing channel close.

D The program panics at runtime.

💡 Hint

Think about what happens when the worker goroutine waits on a channel that never closes.

The worker goroutine waits forever on the channel because it is never closed, causing a goroutine leak.

❓ Predict Output

advanced

Goroutine synchronization with WaitGroup

What is the output of this Go program?

Go

package main

import (
	"fmt"
	"sync"
)

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

A Compilation error due to missing WaitGroup initialization

B All done\nFirst goroutine\nSecond goroutine

C First goroutine\nSecond goroutine\nAll done

D First goroutine\nAll done\nSecond goroutine

💡 Hint

WaitGroup waits for all goroutines to finish before continuing.

The program waits for both goroutines to finish printing before printing "All done".

🧠 Conceptual

expert

Goroutine lifecycle states

Which of the following correctly describes the lifecycle states of a goroutine?

A New, Runnable, Blocked, Terminated

B Created, Running, Waiting, Dead

C Start, Execute, Sleep, Stop

D Init, Active, Paused, Finished

💡 Hint

Think about the main states a goroutine goes through from creation to termination.

Goroutines are created, run, may wait (blocked), and then die (dead) when finished.