Channel synchronization in Go - Step-by-Step Execution

Concept Flow - Channel synchronization

Start main goroutine

↓

Create channel

↓

Start goroutine to send data

↓

Send data into channel

↓

Main goroutine waits to receive

↓

Receive data from channel

↓

Print received data

↓

Program ends

The main goroutine creates a channel and starts another goroutine that sends data into it. The main goroutine waits to receive data from the channel, synchronizing the two goroutines.

Execution Sample

Go

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

This Go program uses a channel to synchronize sending and receiving a string between two goroutines.

Execution Table

Step	Action	Channel State	Goroutine State	Output
1	Create channel ch	empty	main running
2	Start goroutine to send "hello"	empty	main and sender running
3	Sender tries to send "hello" into ch	blocked (waiting for receiver)	sender blocked
4	Main goroutine waits to receive from ch	blocked (waiting for sender)	main blocked
5	Sender sends "hello" into ch	contains "hello"	sender unblocked, ends
6	Main receives "hello" from ch	empty	main unblocked
7	Print "hello"	empty	main running	hello
8	Program ends	empty	all goroutines ended

💡 Program ends after main goroutine prints the received message and all goroutines finish.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 6	Final
ch	empty	blocked (send waiting)	contains "hello"	empty	empty
msg	undefined	undefined	undefined	"hello"	"hello"

Key Moments - 3 Insights

Why does the sender goroutine block when sending to the channel?

Because the channel is unbuffered, the sender waits until the main goroutine receives the value, as shown in step 3 of the execution_table.

How does the main goroutine know when to continue after waiting on the channel?

It continues after receiving the value from the channel, which unblocks it as shown in step 6 of the execution_table.

What happens if the main goroutine tries to receive before the sender sends?

The main goroutine blocks and waits until the sender sends a value, ensuring synchronization, as seen in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the sender goroutine unblock?

A Step 5

B Step 6

C Step 3

D Step 7

💡 Hint

Check the 'Goroutine State' column for the sender goroutine status.

According to variable_tracker, what is the state of channel 'ch' after step 6?

A contains "hello"

B empty

C blocked (send waiting)

D closed

💡 Hint

Look at the 'ch' row under 'After Step 6' in variable_tracker.

If the channel was buffered with capacity 1, how would the sender's state at step 3 change?

A Sender would never send

B Sender would block waiting for receiver

C Sender would send immediately without blocking

D Sender would panic

💡 Hint

Buffered channels allow sending without immediate receiver if buffer space is available.

Concept Snapshot

Channel synchronization in Go:
- Create channel with make(chan Type)
- Sending blocks until receiver is ready (unbuffered channel)
- Receiving blocks until sender sends
- Synchronizes goroutines by waiting on send/receive
- Use channels to safely share data between goroutines

Full Transcript

This example shows how Go uses channels to synchronize two goroutines. The main goroutine creates an unbuffered channel and starts a sender goroutine. The sender tries to send a string into the channel but blocks because the main goroutine has not yet received it. The main goroutine waits to receive from the channel, which unblocks the sender. After the sender sends the string, the main goroutine receives it and prints it. This synchronization ensures safe communication between goroutines without race conditions.