Why channels are used in Go - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program using channels?

Consider this Go code that uses a channel to communicate between goroutines. What will it print?

Go

package main
import (
	"fmt"
)
func main() {
	ch := make(chan string)
	go func() {
		ch <- "Hello from goroutine"
	}()
	msg := <-ch
	fmt.Println(msg)
}

A Empty output

B Compilation error

C Hello from goroutine

D Deadlock error at runtime

💡 Hint

Think about how channels allow communication between goroutines.

The goroutine sends a string to the channel, and the main goroutine receives it and prints it. This is the main use of channels: safe communication between goroutines.

🧠 Conceptual

intermediate

Why are channels important in Go concurrency?

Why do Go programmers use channels when working with goroutines?

A To share memory safely by passing messages

B To replace functions with asynchronous calls

C To create new goroutines automatically

D To speed up the program by avoiding all synchronization

💡 Hint

Think about how channels help avoid data races.

Channels allow goroutines to communicate by sending and receiving values, which helps avoid sharing memory directly and prevents data races.

❓ Predict Output

advanced

What happens if you send on a nil channel?

Look at this Go code snippet. What will happen when it runs?

Go

package main
func main() {
	var ch chan int
	ch <- 5
}

A Compilation error: cannot send on nil channel

B Program deadlocks and panics at runtime

C Program prints 5

D Program exits silently

💡 Hint

A nil channel blocks forever on send or receive.

Sending on a nil channel blocks forever, causing a deadlock and runtime panic.

🔧 Debug

advanced

Why does this Go program deadlock?

This Go program uses a channel but deadlocks. Why?

Go

package main
import "fmt"
func main() {
	ch := make(chan int)
	ch <- 10
	fmt.Println(<-ch)
}

A Because the channel buffer is full

B Because the channel is nil

C Because the channel is closed before sending

D Because the send blocks waiting for a receiver that is not ready

💡 Hint

Think about how unbuffered channels block on send and receive.

Unbuffered channels block the sender until a receiver is ready. Here, the send happens before any receiver, causing deadlock.

🚀 Application

expert

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

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

Go

package main
import "fmt"
func main() {
	ch := make(chan int, 3)
	ch <- 1
	ch <- 2
	ch <- 3
	<-ch
	ch <- 4
	fmt.Println(len(ch))
}

A 2

B 1

C 3

D 0

💡 Hint

Remember that reading from the channel removes one item from the buffer.

The channel buffer size is 3. After sending 3 items, one is received (removed), then one more is sent. The buffer holds 2 items after execution.