Leveraging sync.Pool for Efficient Buffer Reuse in Go

The Problem with Constant Allocations

When you repeatedly create a slice of bytes—say, to read from a network connection or to build a JSON payload—each new incurs two costs:

• Stack allocation for the slice header, and
• Heap allocation for the underlying byte array.

Even if the slice is only a few dozen bytes, the cumulative effect in a high‑throughput service can be dramatic. The Go runtime must track each of these objects, run the mark‑and‑sweep collector, and eventually free them. The result is increased CPU usage, longer GC pauses, and higher memory pressure. In practice, I’ve seen services where >30% of the total CPU time was spent on allocation and deallocation alone.

Introducing sync.Pool

Go provides sync.Pool as a lightweight, thread‑safe way to reuse objects that are expensive to create. The pool works by keeping a per‑goroutine cache of objects; when a goroutine needs an object it can Get one from the pool, and when it’s done it Put it back. Because each goroutine has its own cache, contention is minimal and the overhead of synchronization is essentially zero for the common case.

Practical Example: Reusable Byte Buffers

Below is a production‑ready snippet that demonstrates how to reuse a byte buffer for HTTP response building. The code is deliberately generic so you can adapt it to any scenario where you need a temporary []byte buffer.

import (
    "sync"
)

// globalPool is the shared pool of byte slices.
// The size of the buffer is not fixed; we simply recycle the slice
// so that the underlying memory can be reused across requests.
var globalPool = &sync.Pool{
    New: func() any {
        // Allocate a 256‑byte slice as a starting point.
        // This size is a reasonable default; you can tweak it based on
        // the typical payload size you expect.
        return make([]byte, 0, 256)
    },
}

// GetBuffer retrieves a buffer from the pool and resets its length.
// The returned buffer is safe to use for writing.
func GetBuffer() []byte {
    buf := globalPool.Get().([]byte)
    // Reset the slice for reuse. Keeping the capacity ensures we don’t
    // allocate a new underlying array on the next Write.
    buf = buf[:0]
    return buf
}

// PutBuffer returns a buffer to the pool for future reuse.
// The slice must not be used after this call.
func PutBuffer(buf []byte) {
    // Optionally, we could trim excess capacity here, but most pools
    // keep the buffer as‑is to avoid future allocations.
    globalPool.Put(buf)
}

// Example usage in an HTTP handler:
func MyHandler(w http.ResponseWriter, r *http.Request) {
    // Acquire a buffer from the pool.
    buf := GetBuffer()
    defer PutBuffer(buf) // ensure we recycle it even on early returns.

    // Write JSON or any other payload into the buffer.
    // The buffer grows only if the payload exceeds its capacity.
    json.NewEncoder(buf).Encode(someData)

    // Write the buffer’s contents to the client.
    w.Write(buf.Bytes())
}

The pattern is simple: GetBuffer and PutBuffer wrap the pool’s API, and the handler uses defer PutBuffer to guarantee reclamation. Notice the use of defer—this is a critical safety net because it ensures the buffer is returned even if an exception‑like panic occurs inside the handler.

func LegacyHandler(w http.ResponseWriter, r *http.Request) {
    // Read the entire request body into a freshly allocated slice.
    body, _ := io.ReadAll(r.Body)
    defer r.Body.Close()

    // Marshal a response into another brand‑new slice.
    resp, _ := json.Marshal(process(body))
    w.Write(resp)
}