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.

Practice

1. What is the correct way to send a value 5 to a channel named ch in Go?

easy

A. ch <- 5

B. 5 <- ch

C. send(ch, 5)

D. ch = 5

Solution

1. Step 1: Understand channel send syntax

   In Go, to send a value to a channel, you write channel <- value.

2. Step 2: Apply syntax to given variables

   Here, the channel is ch and the value is 5, so the correct send is ch <- 5.

3. Final Answer:

   ch <- 5 -> Option A

4. Quick Check:

   Send syntax = channel <- value [OK]

Hint: Remember: channel <- value sends data [OK]

Common Mistakes:

• Reversing send syntax as value <- channel
• Using assignment operator instead of send
• Calling a non-existent send function

2. Which of the following is the correct syntax to receive a value from a channel ch and store it in variable v?

easy

A. v := ch <-

B. v = ch <-

C. v = ch.receive()

D. v := <- ch

Solution

1. Step 1: Recall channel receive syntax

   To receive a value from a channel, Go uses value := <- channel.

2. Step 2: Match syntax with variables

   Here, v receives from ch, so v := <- ch is correct.

3. Final Answer:

   v := <- ch -> Option D

4. Quick Check:

   Receive syntax = v := <- ch [OK]

Hint: Use := <- channel to receive value [OK]

Common Mistakes:

• Placing <- after channel name
• Using method calls like receive()
• Using assignment = instead of := for declaration

3. What will be the output of the following Go program?

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

medium

A. 0

B. Compilation error

C. 10

D. Deadlock error

Solution

1. Step 1: Understand channel creation and goroutine

   The channel ch is created and a goroutine sends 10 to it.

2. Step 2: Receive value and print

   The main goroutine receives the value from ch and prints it.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Send and receive work correctly, output = 10 [OK]

Hint: Send in goroutine, receive in main prints sent value [OK]

Common Mistakes:

• Expecting zero value instead of sent value
• Thinking channel blocks forever causing deadlock
• Confusing send and receive syntax

4. Identify the error in this Go code snippet:

package main
func main() {
    ch := make(chan int)
    ch <- 5
    val := <- ch
    println(val)
}

medium

A. Channel is not created properly

B. Sending to channel blocks forever causing deadlock

C. Receiving from channel is incorrect syntax

D. Variable val is not declared

Solution

1. Step 1: Analyze channel usage without goroutine

   The code sends to ch but no goroutine is receiving yet, so send blocks forever.

2. Step 2: Understand deadlock cause

   Since the send blocks and main goroutine waits, program deadlocks before receiving.

3. Final Answer:

   Sending to channel blocks forever causing deadlock -> Option B

4. Quick Check:

   Send blocks without concurrent receiver [OK]

Hint: Send blocks if no goroutine receives concurrently [OK]

Common Mistakes:

• Assuming send works without concurrent receive
• Thinking channel creation is wrong
• Confusing syntax errors with runtime deadlock

5. You want to send multiple values 1, 2, 3 to a channel ch and receive them in order. Which code snippet correctly does this without causing deadlock?

hard

A. ch := make(chan int)
go func() {
ch <- 1
ch <- 2
ch <- 3
}()
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

B. ch := make(chan int)
ch <- 1
ch <- 2
ch <- 3
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

C. ch := make(chan int, 1)
ch <- 1
ch <- 2
ch <- 3
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

D. ch := make(chan int)
for i := 1; i <= 3; i++ {
ch <- i
}
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

Solution

1. Step 1: Check for deadlock prevention

   ch := make(chan int)
   go func() {
       ch <- 1
       ch <- 2
       ch <- 3
   }()
   for i := 0; i < 3; i++ {
       fmt.Println(<-ch)
   }

   uses a goroutine to send values, so sending won't block the main goroutine.

2. Step 2: Confirm receiving order and printing

   Main goroutine receives three values in order and prints them correctly.

3. Final Answer:

   This code runs without deadlock and prints 1, 2, 3 -> Option A

4. Quick Check:

   Use goroutine to send multiple values safely [OK]

Hint: Send in goroutine or use buffered channel to avoid deadlock [OK]

Common Mistakes:

• Sending multiple values on unbuffered channel without goroutine
• Assuming unbuffered channel allows multiple sends without receive
• Forgetting to import fmt for printing