What does sync.Pool's Get return when the pool is empty, and what is the New field for?

## The type `sync.Pool` is a small struct in the `sync` package with one field you fill in and two methods you call: - `New func() any` — a factory the pool calls when it has nothing to hand you. - `Get() any` — removes and returns an item. - `Put(x any)` — offers an item back for reuse. Its zero value is usable, so the idiom is a package-level `var bufPool = sync.Pool{New: func() any { return new(bytes.Buffer) }}`. The pool must not be copied after first use — it contains internal state and a `noCopy` marker, and `go vet`'s copylocks check reports a copy. ## What Get actually promises Very little, deliberately. `Get` selects an *arbitrary* item, removes it from the pool, and returns it. It may ignore whatever is stored and behave as if the pool were empty. Callers must not assume any relation between the values passed to `Put` and the values later returned by `Get`: an object you put may be taken by a different goroutine, or may be dropped entirely and never come back. That last part is the piece people are surprised by. `sync.Pool` is a cache, not storage. The runtime clears pooled entries as part of garbage collection; a victim generation softens the cliff so a burst of work spanning a collection does not lose everything at once, but the guarantee is still "maybe". Anything whose loss would be a correctness problem — an open file, a database connection, a sequence number — does not belong in a `sync.Pool`. ## Why New matters Because `Get` may legitimately return nothing, the pool needs a way to manufacture a replacement. That is `New`. With `New` set, `Get` never returns nil and calling code has exactly one shape: ```go buf := bufPool.Get().(*bytes.Buffer) ``` With `New` left nil, `Get` returns a nil `any` when the pool is empty and that type assertion panics at run time. You would then have to write the comma-ok form and a fallback allocation at every call site — which is what `New` exists to save you from. `New` may be called concurrently by several goroutines, so it must be safe to call at any time; in practice it is a one-line constructor with no shared state. ## The interface boxing detail `Get` returns `any` and `Put` accepts `any`, so every value that goes through the pool passes through an interface. For a pointer such as `*bytes.Buffer` that is free — a pointer fits in the interface word. For a non-pointer value such as a `[]byte` slice header, boxing it into an interface itself allocates, which quietly undoes part of the reason you reached for a pool. That is why the overwhelmingly common shape is a pool of pointers: `*bytes.Buffer`, `*strings.Builder`, or a pointer to a small struct wrapping a `[]byte`. ## Where it is used The canonical case is a scratch buffer on a hot path — for example, a logging library that formats every line into a `bytes.Buffer` before writing it out. Each call needs a buffer, uses it for microseconds, and throws it away; recycling a handful of them across all callers is much cheaper than allocating one per line. The standard library uses the same technique inside its own formatters. ## The rules that come with it Three, and all three follow from the contract above. First, always set `New`. Second, treat an object you hand to `Put` as gone — another goroutine may already be writing into it, so keep no references to it or to any slice that aliases its memory. Third, since the pool hands you whatever the last user left behind, reset the value's state before you use it (or immediately before you put it back), consistently, in exactly one place.