Channel synchronization in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program using channels?

Consider this Go program that uses a channel to synchronize goroutines. What will it print?

Go

package main

import (
	"fmt"
)

func main() {
	ch := make(chan string)
	go func() {
		ch <- "hello"
	}()
	msg := <-ch
	fmt.Println(msg)
}

A hello

B Compilation error

C Deadlock detected at runtime

D Empty line printed

💡 Hint

Think about how the channel is used to pass data between goroutines.

The goroutine sends the string "hello" into the channel. The main goroutine receives it and prints it. So the output is "hello".

❓ Predict Output

intermediate

What happens if you read from a closed channel?

What will this Go program print?

Go

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int)
	go func() {
		ch <- 42
		close(ch)
	}()
	val, ok := <-ch
	fmt.Println(val, ok)
	val, ok = <-ch
	fmt.Println(val, ok)
}

A

42 true
42 true

B

42 true
0 false

C Compilation error

D Deadlock at runtime

💡 Hint

Remember what happens when you read from a closed channel in Go.

Reading from a closed channel returns the zero value and false for the second value. The first read gets 42 and true, the second read gets 0 and false.

🔧 Debug

advanced

Why does this Go program deadlock?

Examine this Go program. It deadlocks at runtime. Why?

Go

package main

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

A Because the channel is nil

B Because the channel is closed before sending

C Because the channel is unbuffered and no goroutine is receiving when sending

D Because the channel is buffered but full

💡 Hint

Think about how unbuffered channels block on send and receive.

The send operation blocks because no goroutine is ready to receive from the unbuffered channel. This causes a deadlock.

📝 Syntax

advanced

Which option correctly creates a buffered channel of size 3?

Choose the correct Go code to create a buffered channel of integers with capacity 3.

A ch := make(chan int[3])

B ch := make(chan int)

C ch := make(chan int, "3")

D ch := make(chan int, 3)

💡 Hint

Recall the syntax of make for buffered channels.

make(chan int, 3) creates a buffered channel with capacity 3. The second argument is the buffer size as an integer.

🚀 Application

expert

How many items are in the channel after this code runs?

Given this Go code, how many items remain in the channel after execution?

Go

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 5)
	for i := 0; i < 3; i++ {
		ch <- i
	}
	<-ch
	ch <- 10
	fmt.Println(len(ch))
}

A 4

B 3

C 2

D 5

💡 Hint

Count how many sends and receives happen on the buffered channel.

Initially 3 items sent, then 1 item received (removes one), then 1 item sent again. So total items in channel: 3 - 1 + 1 = 3. But len(ch) returns 3, so answer is 3.