Sending and receiving values in Go - Step-by-Step Execution

Concept Flow - Sending and receiving values

Start main goroutine

↓

Create channel

↓

Start sender goroutine

↓

Sender sends value into channel

↓

Main goroutine receives value

↓

Print received value

↓

Program ends

This flow shows how a value is sent from one goroutine through a channel and received by another goroutine.

Execution Sample

Go

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

This Go program sends the number 42 through a channel from a goroutine and receives it in main, then prints it.

Execution Table

Step	Action	Channel State	Value Sent/Received	Output
1	Create channel ch	empty	none
2	Start goroutine to send 42	empty	none
3	Goroutine sends 42 into ch	empty	sent 42
4	Main receives from ch	empty	received 42
5	Print received value	empty	42	42
6	Program ends	empty	none

💡 Program ends after printing the received value 42.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
ch	channel created (empty)	empty	empty	empty
val	undefined	undefined	42	42

Key Moments - 3 Insights

Why does the main goroutine wait at val := <-ch?

Because the channel is empty initially, main waits until the goroutine sends a value (see execution_table step 4).

What happens if we try to receive from a channel before any value is sent?

The receive operation blocks and waits until a value is sent, as shown in step 4 where main waits for the goroutine to send 42.

Why do we use a goroutine to send the value?

Because sending on an unbuffered channel blocks until another goroutine receives, so we start a goroutine to avoid deadlock (step 2).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is inside the channel?

A 42

B empty

C undefined

D nil

💡 Hint

Check the 'Channel State' column at step 3 in the execution_table.

At which step does the main goroutine receive the value from the channel?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in the execution_table for when main receives from ch.

If we remove the goroutine and send directly in main, what happens?

A Program deadlocks and never prints

B Program runs and prints 42

C Program panics with error

D Program prints zero value

💡 Hint

Recall that sending on an unbuffered channel blocks until a receiver is ready (see key_moments about blocking).

Concept Snapshot

Go channels let goroutines send and receive values.
Use make(chan Type) to create a channel.
Send with ch <- value, receive with val := <-ch.
Sending or receiving blocks until the other side is ready.
Use goroutines to avoid deadlocks when sending and receiving.

Full Transcript

This example shows how to send and receive values using Go channels. First, a channel is created. Then a goroutine sends the value 42 into the channel. The main goroutine waits to receive this value from the channel. Once received, it prints the value 42. The program ends after printing. The key point is that sending and receiving on an unbuffered channel block until the other side is ready, so we use a goroutine to send the value to avoid deadlock.