Channel Internals: Buffered vs Unbuffered

Channels are typed queues with blocking semantics coordinated by the runtime. An unbuffered channel forces a rendezvous between sender and receiver; a buffered channel stores values in a fixed ring until capacity fills. Close changes send/receive rules and is the idiomatic broadcast signal.

Summary

A channel variable is a descriptor to an hchan structure holding a buffer, send/receive queues of goroutines, and lock-based synchronization. Understanding blocking edges prevents deadlocks, leaks, and misuse of close.

Recipe

Quick-reference recipe card - copy-paste ready.

ch := make(chan int)      // unbuffered - sync handoff
buf := make(chan int, 8)  // buffered - up to 8 sends without receiver
 
buf <- 1
v := <-buf
 
close(buf)
v, ok := <-buf // ok false after buffer drained

When to reach for this:

• Signaling between goroutines with happens-before guarantees
• Worker pools with bounded backlog (buffered)
• Pipeline stages handing off ownership of pointers
• Shutdown broadcast after close (receivers exit loops)

Working Example

package main
 
import (
	"fmt"
	"sync"
)
 
func main() {
	ch := make(chan int, 2)
	var wg sync.WaitGroup
 
	wg.Add(1)
	go func() {
		defer wg.Done()
		ch <- 1
		ch <- 2
		close(ch)
	}()
 
	for v := range ch {
		fmt.Println(v)
	}
	wg.Wait()
}

What this demonstrates:

• Buffered channel accepts two sends without a receiver waiting
• close allows range to drain remaining values then exit
• Only the sender should close in most designs

Deep Dive

How It Works

• hchan structure: Buffer ring, qcount, send/receive wait queues (sudog linked lists), lock, and element type info.
• Unbuffered send: Blocks until a receiver executes receive; values copy directly goroutine to goroutine (handoff).
• Buffered send: Copies into buffer if space; blocks when buffer full until receive frees slot.
• Receive: Blocks when empty (unless closed); on closed empty channel returns zero value and ok == false.

Blocking Rules

Close Semantics

• close(ch): No more sends; receivers get remaining buffered values; future receives get zero with ok == false.
• Multiple receiveers: All blocked receivers wake; one wins each value.
• Select with default: Non-blocking operations use default case when channel not ready.

Go Notes

// Ownership: sender closes when done producing
go func() {
	defer close(out)
	for item := range work {
		out <- process(item)
	}
}()
 
// Do not close from receiver side unless protocol says so
// Range exits when channel closed and drained

Gotchas

• Close by receiver - Closing from the wrong goroutine races with sends. Fix: document producer-closes; use sync.Once only when pattern is clear.
• Send on closed channel - Panics immediately. Fix: guard with select + ctx.Done() or stop sending before close.
• Double close - Panics. Fix: single owner goroutine closes; others signal via context.
• Buffered size 0 vs unbuffered - make(chan T, 0) is unbuffered; still different from forgetting capacity intent. Fix: omit capacity for sync; set explicit buffer for throughput.
• Leaked goroutine blocked on send - No receiver and no cancel path. Fix: combine with context cancellation and select.
• Using channel length for synchronization - len(ch) is a snapshot, not a queue depth contract. Fix: track counts explicitly if protocol requires.

Alternatives

FAQs

Related

• Concurrency Basics - goroutines and select
• Avoiding Goroutine Leaks - shutdown patterns
• Data Types Basics - channel creation intro
• Go's Memory Model - happens-before with channels
• Context Package - cancel alongside channel pipelines

External Related Links

• Go Language Specification - The formal language reference.
• Go by Example - Annotated practical code examples.
• Go Blog (Official) - Official announcements, deep dives, and release notes.
• Concurrency in Go - Katherine Cox-Buday.
• Concurrency in Go (O'Reilly) - Same book on O'Reilly.

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).