Buffered and unbuffered channels in Go - Mini Project: Build & Apply

Buffered and Unbuffered Channels in Go

📖 Scenario: You are building a simple Go program to understand how channels work for communication between goroutines. Channels can be buffered or unbuffered. This project will help you see the difference by creating both types and sending messages through them.

🎯 Goal: Create two channels: one unbuffered and one buffered. Send and receive messages on both channels to observe how they behave differently.

📋 What You'll Learn

Create an unbuffered channel of strings called unbufferedChan

Create a buffered channel of strings called bufferedChan with a capacity of 2

Send a message "hello unbuffered" to unbufferedChan using a goroutine

Send two messages "hello buffered 1" and "hello buffered 2" to bufferedChan

Receive and print messages from both channels

💡 Why This Matters

🌍 Real World

Channels are used in Go programs to safely pass data between different parts of a program running at the same time, like workers in a factory passing items along a conveyor belt.

💼 Career

Understanding channels is essential for Go developers working on concurrent applications such as web servers, data pipelines, and real-time systems.

1

Create an unbuffered channel

Create an unbuffered channel of strings called unbufferedChan using make(chan string).

Go

package main

func main() {
    // Create an unbuffered channel called unbufferedChan
    // Your code here
}

Hint

Use make(chan string) to create an unbuffered channel.

2

Create a buffered channel

Create a buffered channel of strings called bufferedChan with a capacity of 2 using make(chan string, 2).

Go

package main

func main() {
    unbufferedChan := make(chan string)
    // Create a buffered channel called bufferedChan with capacity 2
    // Your code here
}

Hint

Use make(chan string, 2) to create a buffered channel with capacity 2.

3

Send messages to channels

Send the message "hello unbuffered" to unbufferedChan inside a new goroutine using go func() { unbufferedChan <- "hello unbuffered" }(). Then send "hello buffered 1" and "hello buffered 2" to bufferedChan directly.

Go

package main

func main() {
    unbufferedChan := make(chan string)
    bufferedChan := make(chan string, 2)

    // Send "hello unbuffered" to unbufferedChan in a goroutine
    // Send "hello buffered 1" and "hello buffered 2" to bufferedChan
    // Your code here
}

Hint

Use a goroutine to send to the unbuffered channel so the main goroutine can receive it.

4

Receive and print messages from channels

Receive a message from unbufferedChan into msg1 and print it using println(msg1). Then receive two messages from bufferedChan into msg2 and msg3 and print them using println(msg2) and println(msg3).

Go

package main

func main() {
    unbufferedChan := make(chan string)
    bufferedChan := make(chan string, 2)

    go func() {
        unbufferedChan <- "hello unbuffered"
    }()

    bufferedChan <- "hello buffered 1"
    bufferedChan <- "hello buffered 2"

    // Receive from unbufferedChan and print
    // Receive twice from bufferedChan and print
    // Your code here
}

Hint

Use the receive operator <- to get messages from channels and println to display them.

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