4. Buffered Channels

Buffered Channels

Channels can optionally be buffered.

Creating a Channel With a Buffer

You can provide a buffer length as the second argument to make() to create a buffered channel:

ch := make(chan int, 100)

A buffer allows the channel to hold a fixed number of values before sending blocks. This means sending on a buffered channel only blocks when the buffer is full, and receiving blocks only when the buffer is empty.

Buffered Channels - Notes and Assignment

What Are Buffered Channels?

Unbuffered channel:

ch := make(chan int)  // No buffer
// Send blocks immediately until someone receives

Buffered channel:

ch := make(chan int, 100)  // Buffer of 100
// Send only blocks when buffer is full

Creating a Buffered Channel

ch := make(chan Type, bufferSize)

Examples:

ch := make(chan int, 5)           // Can hold 5 ints
msgCh := make(chan string, 10)    // Can hold 10 strings
emailCh := make(chan email, 100)  // Can hold 100 emails

How Buffering Works

Think of it like a queue with limited space:

Buffer size = 3

Empty: [ | | ] ← Can send 3 times without blocking 1 item: [ X | | ] ← Can send 2 more 2 items: [ X | X | ] ← Can send 1 more Full: [ X | X | X ] ← Send blocks until someone receives

Blocking Behavior

Unbuffered (size 0)

ch := make(chan int)

ch <- 1  // Blocks immediately until someone receives

Buffered

ch := make(chan int, 3)

ch <- 1  // Doesn't block (buffer: [1])
ch <- 2  // Doesn't block (buffer: [1, 2])
ch <- 3  // Doesn't block (buffer: [1, 2, 3])
ch <- 4  // BLOCKS! Buffer is full

Assignment

We want to be able to send emails in batches. A writing goroutine will write an entire batch of email messages to a buffered channel, and later, once the channel is full, a reading goroutine will read all of the messages from the channel and send them out to our clients.

Complete the addEmailsToQueue function. It should create a buffered channel with a buffer large enough to store all of the emails it's given. It should then write the emails to the channel in order, and finally return the channel.

Assignment Solution

package main

func addEmailsToQueue(emails []string) chan string {
    // Create buffered channel with space for all emails
    emailCh := make(chan string, len(emails))
    
    // Write all emails to the channel
    for _, email := range emails {
        emailCh <- email
    }
    
    return emailCh
}

Solution Breakdown

1

Create Buffered Channel

emailCh := make(chan string, len(emails))

• Buffer size = number of emails

• This ensures we can add all emails without blocking

2

Write All Emails

for _, email := range emails {
    emailCh <- email
}

• Loops through all emails

• Sends each one into the channel

• Doesn't block because buffer is big enough

3

Return Channel

return emailCh

• Returns the channel full of emails for the reader to process later.

How It Will Be Used

emails := []string{
    "[e-mail]",
    "[e-mail]",
    "[e-mail]",
}

emailCh := addEmailsToQueue(emails)

// Later, read and send emails
for i := 0; i < len(emails); i++ {
    email := <-emailCh
    sendEmail(email)
}

Example Trace

emails := []string{"[e-mail]", "[e-mail]", "[e-mail]"}

emailCh := addEmailsToQueue(emails)

Execution:

1. Create channel with buffer size 3

2. Send "[e-mail]" → buffer: [[e-mail]]

3. Send "[e-mail]" → buffer: [[e-mail], [e-mail]]

4. Send "[e-mail]" → buffer: [[e-mail], [e-mail], [e-mail]]

5. Return channel

No blocking because buffer fits all 3 emails!

Why Use Buffered Channels?

Batch Processing:

// Producer writes batch
ch := make(chan int, 100)
for i := 0; i < 100; i++ {
    ch <- i  // No blocking
}

// Consumer processes batch later
for i := 0; i < 100; i++ {
    process(<-ch)
}

Prevents Blocking:

// Without buffer - blocks on first send
ch := make(chan int)
ch <- 1  // ❌ Deadlock if no receiver

// With buffer - can send without receiver (up to limit)
ch := make(chan int, 5)
ch <- 1  // ✓ Works
ch <- 2  // ✓ Works

Buffered vs Unbuffered

Type	Creation	Send Blocks When	Receive Blocks When
Unbuffered	make(chan int)	Immediately	Channel empty
Buffered	make(chan int,5)	Buffer full	Channel empty

Common Patterns

Pattern: Exact Size Buffer

items := []string{"a", "b", "c"}
ch := make(chan string, len(items))  // Buffer = number of items

for _, item := range items {
    ch <- item  // Never blocks
}

Pattern: Worker Queue

tasks := make(chan Task, 10)  // Buffer 10 tasks

// Producer
for _, task := range allTasks {
    tasks <- task
}

// Consumer
for task := range tasks {
    process(task)
}

Pattern: Rate Limiting

semaphore := make(chan struct{}, 5)  // Max 5 concurrent

for _, task := range tasks {
    semaphore <- struct{}{}  // Acquire
    go func(t Task) {
        process(t)
        <-semaphore  // Release
    }(task)
}

Key Takeaways

1. Buffer syntax: make(chan Type, size)

2. Send blocks when buffer is full

3. Receive blocks when buffer is empty

4. Use buffered for batch processing

5. Buffer size = len(data) for non-blocking writes

Quick Reference

// Unbuffered (blocks immediately on send)
ch := make(chan int)

// Buffered (blocks on send when full)
ch := make(chan int, 10)

// Get buffer capacity
cap(ch)  // 10

// Get current number of items in buffer
len(ch)  // 0-10

Challenge

Buffered Log Collector

Complete the collectLogs function. It should use a buffered channel and a goroutine to send and receive log messages.

You are building a tiny log system for a game server. Logs arrive as a slice of strings. You want to process them using a buffered channel so the sender is not blocked on every single message.

Implement:

func collectLogs(messages []string, bufferSize int) []string

It should:

1

Create a buffered channel of strings with capacity bufferSize.

2

Start a goroutine that:

• Sends every message from messages into the channel.

• Closes the channel after all messages are sent.

3

On the main goroutine (inside collectLogs):

• Receive from the channel until it is closed.

• Collect all received messages in order into a result slice.

4

Return the result slice. The order of messages must be the same as the input order.

Solution

func collectLogs(messages []string, bufferSize int) []string {
    // 1. Create buffered channel
    messageChan := make(chan string, bufferSize)
    
    // 2. Goroutine sends all messages, then closes channel
    go func() {
        for _, mess := range messages {
            messageChan <- mess
        }
        close(messageChan)
    }()
    
    // 3. Main receives all messages into slice
    result := []string{}
    for msg := range messageChan {
        result = append(result, msg)
    }
    
    // 4. Return collected messages
    return result
}

Key Steps

1. Create buffered channel — make(chan string, bufferSize) with specified capacity

2. Spawn goroutine — sends all messages concurrently

3. Close channel — signals no more messages coming

4. Range over channel — receives until closed

5. Build result slice — append each message in order

6. Return slice — contains all messages in original order

Important Concepts

• Buffered Channel: make(chan string, bufferSize) can hold bufferSize messages before blocking.

• close(channel): signals no more values will be sent and allows range to exit.

• range over channel: receives values until channel is closed; preserves FIFO order.

Common Mistakes Avoided

• ❌ Using len(messages) instead of the bufferSize parameter

• ❌ Not using a goroutine to send

• ❌ Forgetting to close the channel

• ❌ Returning channel instead of slice

• ❌ Not receiving from the channel

Why the goroutine must call close() inside it

If close() is called outside the goroutine immediately after starting it, the channel may be closed before the goroutine sends all messages, causing sends on a closed channel (panic). Closing inside the goroutine ensures it's closed only after all sends complete.

Why use go with an immediately-invoked anonymous function

• go func() { ... }() defines and calls an anonymous function as a goroutine.

• Running the send loop in a goroutine allows sending and receiving to proceed concurrently, preventing deadlock when the buffer is smaller than the number of messages.

Flow Diagram (logical)

Main Goroutine	Worker Goroutine
Create channel
Start goroutine ───────────	→ Start sending messages
Continue immediately	mess[0] → channel
Start receiving loop	mess[1] → channel
Receive mess[0] ←──────────	←
Receive mess[1] ←──────────	←

                        |   close(messageChan)

Range loop exits | Goroutine ends

Both sending and receiving happen concurrently, preserving order and avoiding deadlock.