Concurrent execution model in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program with goroutines?

Consider the following Go code that launches two goroutines. What will be printed?

Go

package main

import (
	"fmt"
	"time"
)

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

A Hello from goroutine 1\nMain function finished\nHello from goroutine 2

B Main function finished\nHello from goroutine 1\nHello from goroutine 2

C Main function finished

D Hello from goroutine 1\nHello from goroutine 2\nMain function finished

💡 Hint

Remember that goroutines run concurrently and time.Sleep allows them time to execute before the main function exits.

The two goroutines print their messages concurrently. The time.Sleep call pauses the main goroutine long enough for both goroutines to run and print their messages before the main function prints its final message.

🧠 Conceptual

intermediate

What happens when a Go channel is closed?

In Go, what is the behavior when you read from a closed channel?

A Reading from a closed channel blocks forever.

B Reading from a closed channel causes a runtime panic.

C Reading from a closed channel returns the zero value immediately without blocking.

D Reading from a closed channel returns the last value sent before closing.

💡 Hint

Think about how channels signal no more values will be sent.

When a channel is closed, reading from it returns the zero value of the channel's type immediately and does not block. This allows goroutines to detect the channel closure.

🔧 Debug

advanced

Identify the cause of deadlock in this Go program

Examine the following Go code. What causes the deadlock?

Go

package main

func main() {
	ch := make(chan int)
	ch <- 1
	<-ch
}

A The program deadlocks because the channel is closed before receiving.

B The program deadlocks because the send operation blocks with no receiver ready.

C The program deadlocks because the receive operation blocks with no sender ready.

D The program does not deadlock and prints 1.

💡 Hint

Consider how unbuffered channels block on send and receive.

The channel is unbuffered, so sending blocks until another goroutine receives. Since the send happens in main and no other goroutine receives yet, the program deadlocks.

📝 Syntax

advanced

Which option correctly declares and starts a goroutine?

Which of the following Go code snippets correctly declares and starts a goroutine that prints "Hi"?

A go func() { fmt.Println("Hi") }()

B func go() { fmt.Println("Hi") }()

C go fmt.Println("Hi")()

D go func { fmt.Println("Hi") }()

💡 Hint

Remember the syntax for anonymous functions and starting goroutines.

Option A correctly defines an anonymous function and immediately calls it as a goroutine. Other options have syntax errors or misuse the go keyword.

🚀 Application

expert

How many items are received from this buffered channel?

Given the following Go code, how many values will be received and printed?

Go

package main

import "fmt"

func main() {
	ch := make(chan int, 3)
	ch <- 10
	ch <- 20
	close(ch)

	count := 0
	for v := range ch {
		fmt.Println(v)
		count++
	}
	fmt.Println("Total received:", count)
}

A 2

B 0

C 3

D 1

💡 Hint

Think about how many values were sent before closing the channel.

The channel buffer size is 3, but only 2 values (10 and 20) were sent before closing. The range loop receives these 2 values and then stops.