Buffered and unbuffered channels in Go - Step-by-Step Execution

Concept Flow - Buffered and unbuffered channels

Create channel

↓

Send data

↓

Unbuffered?

↓

Wait receiver

↓

Receiver ready

↓

Data received

Shows how data is sent and received differently in unbuffered and buffered channels.

Execution Sample

Go

ch := make(chan int) // unbuffered

// goroutine to send
go func() {
	ch <- 42
}()

// main goroutine receives
val := <-ch

This code creates an unbuffered channel, sends a value, and receives it, showing synchronization.

Execution Table

Step	Action	Channel State	Sender Blocked?	Receiver Blocked?	Output
1	Create unbuffered channel	empty	No	No
2	Send 42 to channel	empty (waiting for receiver)	Yes	No
3	Receive from channel	empty	No	No	42
4	Send completes	empty	No	No	42
5	Program ends	empty	No	No	42

💡 Send blocks until receive happens; after receive, send completes and value is output.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
ch (channel)	empty	waiting for receiver	empty	empty
val (received)	undefined	undefined	42	42

Key Moments - 2 Insights

Why does the send operation block in an unbuffered channel?

Because unbuffered channels require a receiver to be ready before the send can complete, as shown in step 2 of the execution_table.

What happens to the channel state after the receiver reads the value?

The channel becomes empty again, allowing the send to complete, as seen in step 3 and 4 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the sender stop being blocked?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Check the 'Sender Blocked?' column in execution_table rows for steps 2 to 4.

According to variable_tracker, what is the value of 'val' after step 3?

A 42

B 0

C undefined

D empty

💡 Hint

Look at the 'val (received)' row and 'After Step 3' column in variable_tracker.

If the channel was buffered with capacity 1, how would the sender behave at step 2?

A Sender blocks until receiver reads

B Sender does not block and stores value in buffer

C Sender blocks forever

D Sender skips sending

💡 Hint

Buffered channels allow one value to be stored without blocking; compare with unbuffered behavior in execution_table.

Concept Snapshot

Channels in Go can be unbuffered or buffered.
Unbuffered channels block the sender until the receiver is ready.
Buffered channels store values up to their capacity without blocking.
Use make(chan Type, capacity) to create buffered channels.
Send blocks if buffer is full; receive blocks if buffer is empty.

Full Transcript

This visual execution shows how unbuffered channels in Go synchronize sending and receiving. When a channel is unbuffered, sending a value blocks until another goroutine receives it. The channel state changes from empty to waiting for a receiver during send, then back to empty after receive. Variables track the channel state and received value. Key moments include understanding why send blocks and how the channel empties after receive. The quiz tests understanding of blocking behavior and variable values. Buffered channels differ by allowing sends without immediate receive if buffer space exists.