Buffered Channels

In this lesson, explore buffered channels through one small Go program, and connect its output to the language rules behind it.

make(chan T, capacity) allows up to capacity values to wait in a channel without an immediate receiver. Send blocks when the buffer is full; receive blocks when it is empty.

Capacity reduces some waiting but does not eliminate backpressure or guarantee fairness.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

func main() {
	jobs := make(chan string, 2)
	jobs <- "first"
	jobs <- "second"
	fmt.Println("Queued:", len(jobs), "Capacity:", cap(jobs))
	fmt.Println(<-jobs, <-jobs)
}

Output

Queued: 2 Capacity: 2
first second

Two sends fit into the buffer and the program prints the length and capacity as 2. Values come out in send order.

• Buffer capacity is not a maximum number of goroutines.
• A full buffer still blocks the next send.

Change the buffer to capacity 3 and send three values before receiving them.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Buffered Channels in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.