Buffered and unbuffered channels in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an unbuffered channel in Go?

An unbuffered channel in Go is a channel with no capacity to hold data. It requires both sender and receiver to be ready at the same time for communication to happen, ensuring synchronization.

beginner

What is a buffered channel in Go?

A buffered channel in Go has a capacity to hold a fixed number of values. Senders can send data without waiting for a receiver until the buffer is full, allowing asynchronous communication up to the buffer size.

beginner

How do you create a buffered channel in Go?

You create a buffered channel using the make function with a capacity argument, like: ch := make(chan int, 3). This channel can hold 3 integers before blocking the sender.

intermediate

What happens when you send to a full buffered channel?

When you send to a buffered channel that is full, the sending goroutine blocks until some data is received from the channel, freeing space in the buffer.

intermediate

Why use buffered channels instead of unbuffered channels?

Buffered channels allow some decoupling between sender and receiver, letting the sender continue without waiting immediately. This can improve performance and avoid deadlocks in some cases.

What does an unbuffered channel guarantee in Go?

A Sender and receiver synchronize on each send and receive

B Sender can send multiple values without blocking

C Channel can hold multiple values in a queue

D Sender never blocks

Unbuffered channels require sender and receiver to be ready at the same time, ensuring synchronization.

How do you declare a buffered channel with capacity 5 in Go?

A ch := make(chan int)

B ch := chan int{5}

C var ch chan int = 5

D ch := make(chan int, 5)

Use make with a second argument for capacity: make(chan int, 5).

What happens if you send to a buffered channel that is not full?

A Send blocks until buffer is empty

B Send proceeds immediately without blocking

C Send blocks until receiver is ready

D Send causes a runtime error

If the buffer is not full, send does not block and proceeds immediately.

Which of these is true about buffered channels?

A They always block the sender

B They never block the receiver

C They can hold multiple values up to their capacity

D They are slower than unbuffered channels

Buffered channels hold multiple values up to their capacity before blocking the sender.

Why might you choose an unbuffered channel?

A To ensure sender and receiver synchronize on each message

B To store many messages in a queue

C To avoid blocking the sender

D To allow asynchronous communication

Unbuffered channels ensure synchronization between sender and receiver on each message.

Explain the difference between buffered and unbuffered channels in Go.

Think about whether the sender waits or not.

Describe a situation where using a buffered channel is better than an unbuffered channel.

Consider when you want to let sender continue without waiting.

Practice

1. What is the main difference between a buffered and an unbuffered channel in Go?

easy

A. Buffered channels allow sending multiple values without waiting, unbuffered channels require receiver ready.

B. Unbuffered channels store values internally, buffered channels do not.

C. Buffered channels block the sender until the receiver reads, unbuffered channels never block.

D. Unbuffered channels can only send strings, buffered channels can send any type.

Solution

1. Step 1: Understand unbuffered channel behavior

   Unbuffered channels require the sender to wait until the receiver is ready to receive the value.

2. Step 2: Understand buffered channel behavior

   Buffered channels have a capacity to hold multiple values, so the sender can send without waiting until the buffer is full.

3. Final Answer:

   Buffered channels allow sending multiple values without waiting, unbuffered channels require receiver ready. -> Option A

4. Quick Check:

   Buffered vs unbuffered = sender wait or not [OK]

Hint: Buffered = sender can send without waiting until full [OK]

Common Mistakes:

• Thinking unbuffered channels store values internally
• Believing buffered channels never block sender
• Confusing data types allowed in channels

2. Which of the following is the correct way to create a buffered channel of integers with capacity 3 in Go?

easy

A. ch := make(chan int)

B. ch := make(chan int[3])

C. ch := make(chan int, 3)

D. ch := new(chan int, 3)

Solution

1. Step 1: Recall syntax for buffered channel creation

   Buffered channels are created with make(chan Type, capacity). Here, capacity is 3.

2. Step 2: Check each option

   ch := make(chan int, 3) uses make(chan int, 3) which is correct. ch := make(chan int) creates unbuffered channel. ch := make(chan int[3]) has invalid syntax. ch := new(chan int, 3) uses new which is incorrect for channels.

3. Final Answer:

   ch := make(chan int, 3) -> Option C

4. Quick Check:

   Buffered channel syntax = make(chan Type, capacity) [OK]

Hint: Use make(chan Type, capacity) for buffered channels [OK]

Common Mistakes:

• Omitting capacity creates unbuffered channel
• Using new() instead of make()
• Incorrect syntax with array notation

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

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

medium

A. Compilation error

B. 10

C. Deadlock error

D. 0

Solution

1. Step 1: Analyze channel type and goroutine

   The channel ch is unbuffered. The goroutine sends 10 to ch, and main receives from ch.

2. Step 2: Understand synchronization

   Because the send and receive happen in separate goroutines, the send blocks until receive is ready, so the program runs without deadlock and prints 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Unbuffered channel with goroutine send = prints sent value [OK]

Hint: Unbuffered channel blocks sender until receiver ready [OK]

Common Mistakes:

• Expecting deadlock without goroutine
• Thinking unbuffered channel stores default zero
• Confusing compilation error with runtime behavior

4. Consider this Go code snippet:

ch := make(chan int, 2)
ch <- 1
ch <- 2
ch <- 3
fmt.Println(<-ch)

What is the problem with this code?

medium

A. It causes a compilation error due to wrong syntax.

B. It prints 3 because the last value overwrites the buffer.

C. It compiles but prints 0 because channel is empty.

D. It causes a deadlock because the buffered channel is full before the third send.

Solution

1. Step 1: Check channel buffer capacity and sends

   The channel has capacity 2. Two sends fill the buffer. The third send blocks because buffer is full and no receiver yet.

2. Step 2: Understand blocking behavior

   Since no goroutine is receiving before the third send, the program deadlocks at third send.

3. Final Answer:

   It causes a deadlock because the buffered channel is full before the third send. -> Option D

4. Quick Check:

   Buffered channel full + send without receive = deadlock [OK]

Hint: Buffered channel blocks sender when full without receiver [OK]

Common Mistakes:

• Assuming buffer overwrites old values
• Expecting zero printed from empty channel
• Confusing syntax error with runtime deadlock

5. You want to send 5 integers to a channel without blocking the sender immediately. Which of these code snippets correctly achieves this using buffered channels?

Option A:
ch := make(chan int, 5)
for i := 1; i <= 5; i++ {
  ch <- i
}

Option B:
ch := make(chan int)
for i := 1; i <= 5; i++ {
  ch <- i
}

Option C:
ch := make(chan int, 3)
for i := 1; i <= 5; i++ {
  ch <- i
}

Option D:
ch := make(chan int, 0)
for i := 1; i <= 5; i++ {
  ch <- i
}

hard

A. Option A only

B. Option B only

C. Option C only

D. Option D only

Solution

1. Step 1: Understand buffered channel capacity

   To send 5 integers without blocking immediately, the channel buffer must be at least 5.

2. Step 2: Analyze each snippet's buffer size

   The first snippet creates a channel with capacity 5, allowing all 5 sends without blocking. The second creates an unbuffered channel, blocking the sender immediately on the first send. The third has capacity 3, blocking on the fourth send. The fourth has capacity 0 (unbuffered), blocking immediately.

3. Final Answer:

   Option A only -> Option A

4. Quick Check:

   Buffer size >= sends to avoid blocking [OK]

Hint: Buffer size must match sends to avoid blocking [OK]

Common Mistakes:

• Using unbuffered channels expecting no blocking
• Choosing smaller buffer than sends
• Misunderstanding buffer size zero means unbuffered