Buffered vs Unbuffered Chan

Part of the Object Oriented Programming section of Coddy's GO journey — lesson 61 of 107.

The channels we've used so far are unbuffered—they have no capacity to hold values. A send operation blocks until another goroutine receives, and vice versa. Buffered channels add internal storage, allowing sends to complete without an immediate receiver.

Create a buffered channel by passing a capacity to make:

// Unbuffered - capacity 0
unbuffered := make(chan int)

// Buffered - capacity 3
buffered := make(chan int, 3)

With a buffered channel, sends only block when the buffer is full, and receives only block when the buffer is empty:

ch := make(chan string, 2)

ch <- "first"   // doesn't block - buffer has space
ch <- "second"  // doesn't block - buffer has space
// ch <- "third" would block - buffer is full

fmt.Println(<-ch)  // "first"
fmt.Println(<-ch)  // "second"

Use len(ch) to check how many items are currently in the buffer, and cap(ch) for the total capacity.

When to use each: Unbuffered channels provide tight synchronization—the sender knows the receiver got the value. Buffered channels decouple sender and receiver timing, useful when producers and consumers work at different speeds. However, buffered channels can mask synchronization bugs, so prefer unbuffered unless you have a specific reason for buffering.

Challenge

Easy

Let's build a batch processor that demonstrates the difference between buffered and unbuffered channels. You'll create a system where a producer sends items to a processor, using buffered channels to decouple their timing and allow the producer to work ahead.

You'll organize your code across two files:

processor.go: Define your batch processing logic using channels.
Create an Item struct with ID (int) and Value (string) fields.

Implement two functions:
- Producer(items []Item, out chan Item) - Sends each item to the output channel. After sending each item, print: Produced item [ID]. After all items are sent, print the current number of items waiting in the buffer using len(out) in the format: Buffer has [count] items. Then close the channel.
- Consumer(in chan Item) []string - Receives items from the input channel and collects them into a slice of formatted strings. For each received item, the string should be: Consumed: [ID] - [Value]. Return the slice when the channel is closed.
main.go: Set up the buffered channel and coordinate the producer and consumer.
Read the buffer capacity, then the number of items, followed by each item's ID and value. Create a buffered channel with the specified capacity. Run the Producer first (not as a goroutine) to fill the buffer, then run the Consumer to process all items. Print each consumed result on a separate line.

The following inputs will be provided:

Line 1: Buffer capacity (integer)
Line 2: Number of items (integer)
Following lines: For each item, two lines - the item ID (integer), then its value (string)

For example, given:

3
3
1
apple
2
banana
3
cherry

Your output should be:

Produced item 1
Produced item 2
Produced item 3
Buffer has 3 items
Consumed: 1 - apple
Consumed: 2 - banana
Consumed: 3 - cherry

Notice how with a buffer capacity of 3, the producer can send all 3 items without blocking, and the buffer shows 3 items waiting before the consumer starts. If the buffer were smaller than the number of items, the producer would block waiting for space.

Cheat sheet

Channels in Go can be unbuffered (capacity 0) or buffered (with internal storage).

Create channels with make:

// Unbuffered - capacity 0
unbuffered := make(chan int)

// Buffered - capacity 3
buffered := make(chan int, 3)

Buffered channel behavior:

Sends block only when the buffer is full
Receives block only when the buffer is empty

ch := make(chan string, 2)

ch <- "first"   // doesn't block - buffer has space
ch <- "second"  // doesn't block - buffer has space
// ch <- "third" would block - buffer is full

fmt.Println(<-ch)  // "first"
fmt.Println(<-ch)  // "second"

Check buffer status:

len(ch) - number of items currently in the buffer
cap(ch) - total buffer capacity

When to use:

Unbuffered: Tight synchronization—sender knows receiver got the value
Buffered: Decouple sender and receiver timing when they work at different speeds

Try it yourself

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Read buffer capacity
	line, _ := reader.ReadString('\n')
	bufferCapacity, _ := strconv.Atoi(strings.TrimSpace(line))

	// Read number of items
	line, _ = reader.ReadString('\n')
	numItems, _ := strconv.Atoi(strings.TrimSpace(line))

	// Read each item's ID and value
	items := make([]Item, numItems)
	for i := 0; i < numItems; i++ {
		line, _ = reader.ReadString('\n')
		id, _ := strconv.Atoi(strings.TrimSpace(line))
		line, _ = reader.ReadString('\n')
		value := strings.TrimSpace(line)
		items[i] = Item{ID: id, Value: value}
	}

	// TODO: Create a buffered channel with the specified capacity

	// TODO: Run the Producer (not as a goroutine) to fill the buffer

	// TODO: Run the Consumer to process all items

	// TODO: Print each consumed result on a separate line
}