Object Pool — Hands-on Tasks¶

package main

import (
    "bytes"
    "fmt"
    "sync"
)

// Senior decision: pool at package scope. Re-creating it per call is
// just a slow allocator. One pool serves the whole process lifetime.
var bufPool = sync.Pool{
    New: func() any {
        // Cheap zero-value. No I/O, no big alloc in New — if New is
        // expensive, the pool's benefit erodes on every miss.
        return new(bytes.Buffer)
    },
}

func render(name string) string {
    buf := bufPool.Get().(*bytes.Buffer)
    // Senior decision: Reset BEFORE writing. The previous borrower left
    // whatever it wrote in there. Skipping this is the #1 production bug.
    buf.Reset()
    // Senior decision: defer Put right after Get. If anything panics,
    // the deferred Put still runs and the pool stays healthy.
    defer bufPool.Put(buf)
    buf.WriteString("hello, ")
    buf.WriteString(name)
    // Senior decision: copy out. The buffer goes back to the pool; its
    // internal slice is shared with the next borrower.
    return buf.String()
}

func main() {
    fmt.Println(render("alice"))
    fmt.Println(render("bob"))
    fmt.Println(render("carol"))
}

package main

import (
    "bytes"
    "fmt"
    "sync"
)

var bufPool = sync.Pool{New: func() any { return new(bytes.Buffer) }}

// dirty: deliberately broken.
func dirty(name string) string {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf)
    // No Reset! Old content stays.
    buf.WriteString("hello, ")
    buf.WriteString(name)
    return buf.String()
}

func clean(name string) string {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf)
    // Senior decision: Reset is mandatory for any growable container
    // (Buffer, slice, map). The pool reuses memory, not values.
    buf.Reset()
    buf.WriteString("hello, ")
    buf.WriteString(name)
    return buf.String()
}

func main() {
    fmt.Println("=== dirty ===")
    fmt.Println(dirty("alice"))
    fmt.Println(dirty("bob"))   // -> "hello, alicehello, bob"
    fmt.Println(dirty("carol")) // -> "hello, alicehello, bobhello, carol"
    fmt.Println("=== clean ===")
    fmt.Println(clean("alice"))
    fmt.Println(clean("bob"))
    fmt.Println(clean("carol"))
}

// File: bufbench_test.go — go test -bench=. -benchmem -benchtime=3s
package bufbench

import (
    "bytes"
    "strconv"
    "sync"
    "testing"
)

// Senior decision: 256-byte workload. Roughly an HTTP header block.
// Too small and pool overhead swamps the savings.
func write256(buf *bytes.Buffer, i int) {
    buf.WriteString("user=")
    buf.WriteString(strconv.Itoa(i))
    buf.WriteString(" path=/api/v1/orders/")
    buf.WriteString(strconv.Itoa(i))
    buf.WriteString(" method=GET ts=2026-05-28 ua=Mozilla/5.0")
}

func BenchmarkNoPool(b *testing.B) {
    b.ReportAllocs()
    for i := 0; i < b.N; i++ {
        var buf bytes.Buffer
        write256(&buf, i)
        _ = buf.String()
    }
}

func BenchmarkWithPool(b *testing.B) {
    pool := sync.Pool{New: func() any { return new(bytes.Buffer) }}
    b.ReportAllocs()
    for i := 0; i < b.N; i++ {
        buf := pool.Get().(*bytes.Buffer)
        buf.Reset()
        write256(buf, i)
        _ = buf.String()
        pool.Put(buf)
    }
}

// Senior decision: jagged workload exposes the size-cap trap (task 5).
func BenchmarkWithPoolJagged(b *testing.B) {
    pool := sync.Pool{New: func() any { return new(bytes.Buffer) }}
    b.ReportAllocs()
    for i := 0; i < b.N; i++ {
        buf := pool.Get().(*bytes.Buffer)
        buf.Reset()
        n := 256
        if i%1000 == 0 {
            n = 64 << 10
        }
        for j := 0; j < n/8; j++ {
            buf.WriteString("xxxxxxxx")
        }
        pool.Put(buf)
    }
}

/*
Typical output:
  BenchmarkNoPool-10       8000000  180 ns/op  256 B/op  2 allocs/op
  BenchmarkWithPool-10    20000000   60 ns/op    0 B/op  0 allocs/op
With pool: 3x faster, allocations near zero.
*/

package main

import (
    "fmt"
    "sync"
)

type Request struct {
    Headers map[string]string
    Body    []byte
}

var reqPool = sync.Pool{
    New: func() any {
        // Senior decision: pre-size inner allocations. The point of
        // pooling is to avoid grow-and-copy. First borrow pays the cost,
        // every subsequent borrow reuses the grown structures.
        return &Request{
            Headers: make(map[string]string, 16),
            Body:    make([]byte, 0, 4096),
        }
    },
}

func borrowRequest() *Request { return reqPool.Get().(*Request) }

func returnRequest(r *Request) {
    // Senior decision: CLEAR, do not REPLACE. Replacing throws away the
    // very memory we wanted to reuse — and the new empty map/slice will
    // grow again on the next borrower.
    for k := range r.Headers {
        delete(r.Headers, k)
    }
    r.Body = r.Body[:0]
    reqPool.Put(r)
}

func handle(method, path string, body []byte) {
    r := borrowRequest()
    defer returnRequest(r)
    r.Headers["method"] = method
    r.Headers["path"] = path
    r.Body = append(r.Body, body...)
    fmt.Printf("addr=%p %s %s body-cap=%d\n", r, method, path, cap(r.Body))
}

func main() {
    handle("GET", "/api/v1/orders", []byte(`{"page":1}`))
    handle("POST", "/api/v1/orders", []byte(`{"item":"book"}`))
    handle("DELETE", "/api/v1/orders/42", nil)
}

package main

import (
    "bytes"
    "fmt"
    "sync"
)

// Senior decision: 64 KB is defensible for HTTP. Largest "normal"
// response is ~16 KB; 4x that absorbs spikes without one outlier
// pinning a megabyte of memory forever.
const maxBufCap = 64 << 10

var bufPool = sync.Pool{New: func() any { return new(bytes.Buffer) }}

func getBuf() *bytes.Buffer {
    b := bufPool.Get().(*bytes.Buffer)
    b.Reset()
    return b
}

func putBuf(b *bytes.Buffer) {
    // Senior decision: cap check at Put, not Get. Catching bloat on
    // return is the standard form — encoding/json's encodeStatePool
    // does exactly this.
    if b.Cap() > maxBufCap {
        fmt.Printf("[pool] dropping oversized buf cap=%d\n", b.Cap())
        return
    }
    bufPool.Put(b)
}

func renderSmall() {
    b := getBuf()
    defer putBuf(b)
    for i := 0; i < 100; i++ {
        b.WriteString("hello\n")
    }
}

func renderHuge() {
    b := getBuf()
    defer putBuf(b)
    for i := 0; i < 1<<20; i++ {
        b.WriteByte('x')
    }
}

func main() {
    renderSmall()
    renderHuge()  // drops on Put
    renderSmall() // gets a fresh (or pooled small) buf
}

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

type WorkerPool struct {
    jobs chan func()
    wg   sync.WaitGroup
}

func New(workers, queueDepth int) *WorkerPool {
    p := &WorkerPool{
        // Senior decision: buffered channel. queueDepth gives bursts
        // a place to land; past it Submit blocks — backpressure for free.
        jobs: make(chan func(), queueDepth),
    }
    for i := 0; i < workers; i++ {
        p.wg.Add(1)
        go p.worker()
    }
    return p
}

func (p *WorkerPool) worker() {
    defer p.wg.Done()
    // Senior decision: do NOT recover panics unless you know why.
    // A panic indicates a bug; swallowing hides it and the goroutine still dies.
    for f := range p.jobs {
        f()
    }
}

func (p *WorkerPool) Submit(f func()) { p.jobs <- f }

func (p *WorkerPool) Close() {
    close(p.jobs)
    p.wg.Wait()
}

func main() {
    p := New(4, 16)
    var done int64
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        i := i
        p.Submit(func() {
            defer wg.Done()
            time.Sleep(time.Duration(i%5) * time.Millisecond)
            atomic.AddInt64(&done, 1)
        })
    }
    wg.Wait()
    p.Close()
    fmt.Println("completed:", done)
}

package main

import (
    "context"
    "errors"
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

type WorkerPool struct {
    jobs   chan func(context.Context)
    wg     sync.WaitGroup
    ctx    context.Context
    cancel context.CancelFunc
    closed atomic.Bool
}

var ErrPoolClosed = errors.New("pool: closed")

func New(workers, depth int) *WorkerPool {
    ctx, cancel := context.WithCancel(context.Background())
    p := &WorkerPool{jobs: make(chan func(context.Context), depth), ctx: ctx, cancel: cancel}
    for i := 0; i < workers; i++ {
        p.wg.Add(1)
        go p.worker()
    }
    return p
}

func (p *WorkerPool) worker() {
    defer p.wg.Done()
    // Senior decision: pass pool ctx to the job so jobs that respect
    // ctx.Done() can be interrupted on hard shutdown.
    for f := range p.jobs {
        f(p.ctx)
    }
}

func (p *WorkerPool) Submit(f func(context.Context)) error {
    if p.closed.Load() {
        return ErrPoolClosed
    }
    select {
    case p.jobs <- f:
        return nil
    case <-p.ctx.Done():
        return ErrPoolClosed
    }
}

func (p *WorkerPool) Shutdown(ctx context.Context) error {
    if !p.closed.CompareAndSwap(false, true) {
        return ErrPoolClosed
    }
    close(p.jobs)
    done := make(chan struct{})
    go func() { p.wg.Wait(); close(done) }()
    select {
    case <-done:
        p.cancel()
        return nil
    case <-ctx.Done():
        // Senior decision: cancel, then STILL wait for wg. Returning
        // early would leave goroutines running past Shutdown.
        p.cancel()
        <-done
        return ctx.Err()
    }
}

func main() {
    p := New(2, 8)
    var done int64
    for i := 0; i < 5; i++ {
        i := i
        _ = p.Submit(func(ctx context.Context) {
            select {
            case <-time.After(100 * time.Millisecond):
                atomic.AddInt64(&done, 1)
            case <-ctx.Done():
                fmt.Printf("job %d cancelled\n", i)
            }
        })
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    if err := p.Shutdown(ctx); err != nil {
        fmt.Println("shutdown:", err)
    }
    fmt.Println("done:", done)
    if err := p.Submit(func(context.Context) {}); err != nil {
        fmt.Println("expected:", err)
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "sync"
)

const maxBufCap = 64 << 10

// encState bundles a buffer with its encoder. Pooling just the buffer
// would force a new Encoder per call, throwing away the type cache.
type encState struct {
    buf *bytes.Buffer
    enc *json.Encoder
}

var encPool = sync.Pool{
    New: func() any {
        buf := new(bytes.Buffer)
        enc := json.NewEncoder(buf)
        // Senior decision: configure once at New. The encoder is reused
        // with the same settings on every borrow.
        enc.SetEscapeHTML(false)
        return &encState{buf: buf, enc: enc}
    },
}

func marshal(v any) ([]byte, error) {
    st := encPool.Get().(*encState)
    defer putState(st)
    st.buf.Reset()
    if err := st.enc.Encode(v); err != nil {
        return nil, fmt.Errorf("marshal: %w", err)
    }
    b := st.buf.Bytes()
    if n := len(b); n > 0 && b[n-1] == '\n' {
        b = b[:n-1]
    }
    // Senior decision: copy out. The pool reclaims st.buf next.
    out := make([]byte, len(b))
    copy(out, b)
    return out, nil
}

func putState(st *encState) {
    if st.buf.Cap() > maxBufCap {
        return
    }
    encPool.Put(st)
}

func main() {
    type User struct {
        ID   int      `json:"id"`
        Name string   `json:"name"`
        Tags []string `json:"tags,omitempty"`
    }
    for _, u := range []User{{1, "alice", []string{"admin"}}, {2, "bob", nil}} {
        b, _ := marshal(u)
        fmt.Println(string(b))
    }
}

package main

import (
    "fmt"
    "sync"
)

// Senior decision: a typed wrapper that keeps sync.Pool's per-P fast
// path and adds (a) compile-time type safety, (b) a Reset hook so the
// user does not have to remember it on Get.
type Pool[T any] struct {
    inner sync.Pool
    reset func(*T)
}

func NewPool[T any](newFn func() *T, resetFn func(*T)) *Pool[T] {
    return &Pool[T]{
        inner: sync.Pool{New: func() any { return newFn() }},
        reset: resetFn,
    }
}

func (p *Pool[T]) Get() *T { return p.inner.Get().(*T) }

func (p *Pool[T]) Put(x *T) {
    if p.reset != nil {
        p.reset(x)
    }
    p.inner.Put(x)
}

type Request struct {
    Headers map[string]string
    Body    []byte
}

func newRequest() *Request {
    return &Request{Headers: make(map[string]string, 16), Body: make([]byte, 0, 4096)}
}

func resetRequest(r *Request) {
    for k := range r.Headers {
        delete(r.Headers, k)
    }
    r.Body = r.Body[:0]
}

var reqPool = NewPool(newRequest, resetRequest)

func main() {
    r1 := reqPool.Get()
    r1.Headers["path"] = "/api/orders"
    r1.Body = append(r1.Body, []byte(`{"page":1}`)...)
    fmt.Printf("r1=%p body=%s\n", r1, r1.Body)
    reqPool.Put(r1)
    r2 := reqPool.Get()
    fmt.Printf("r2=%p headers=%d body-len=%d cap=%d\n",
        r2, len(r2.Headers), len(r2.Body), cap(r2.Body))
    reqPool.Put(r2)
}

package main

import (
    "context"
    "errors"
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

type Conn struct {
    ID     int
    Closed bool
}

func (c *Conn) Close() { c.Closed = true }

type Pool struct {
    mu      sync.Mutex
    idle    chan *Conn
    open    int
    max     int
    closed  bool
    dial    func(ctx context.Context) (*Conn, error)
}

var ErrPoolClosed = errors.New("pool: closed")

func NewPool(max int, dial func(ctx context.Context) (*Conn, error)) *Pool {
    return &Pool{idle: make(chan *Conn, max), max: max, dial: dial}
}

func (p *Pool) Get(ctx context.Context) (*Conn, error) {
    p.mu.Lock()
    if p.closed {
        p.mu.Unlock()
        return nil, ErrPoolClosed
    }
    p.mu.Unlock()
    // Senior decision: try non-blocking idle first. Otherwise a fresh
    // request would wait for a free conn even when we could dial cheaply.
    select {
    case c := <-p.idle:
        return c, nil
    default:
    }
    p.mu.Lock()
    if p.open < p.max {
        p.open++
        p.mu.Unlock()
        c, err := p.dial(ctx)
        if err != nil {
            p.mu.Lock()
            p.open--
            p.mu.Unlock()
            return nil, fmt.Errorf("dial: %w", err)
        }
        return c, nil
    }
    p.mu.Unlock()
    select {
    case c := <-p.idle:
        return c, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

func (p *Pool) Put(c *Conn) {
    if c == nil {
        return
    }
    if c.Closed {
        p.mu.Lock()
        p.open--
        p.mu.Unlock()
        return
    }
    select {
    case p.idle <- c:
    default:
        c.Close()
        p.mu.Lock()
        p.open--
        p.mu.Unlock()
    }
}

func (p *Pool) Close() {
    p.mu.Lock()
    if p.closed {
        p.mu.Unlock()
        return
    }
    p.closed = true
    close(p.idle)
    p.mu.Unlock()
    for c := range p.idle {
        c.Close()
    }
}

var nextID atomic.Int64

func fakeDial(ctx context.Context) (*Conn, error) {
    select {
    case <-time.After(5 * time.Millisecond):
        return &Conn{ID: int(nextID.Add(1))}, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

func main() {
    p := NewPool(3, fakeDial)
    defer p.Close()
    ctx := context.Background()
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            c, err := p.Get(ctx)
            if err != nil {
                fmt.Printf("w%d err: %v\n", i, err)
                return
            }
            defer p.Put(c)
            time.Sleep(20 * time.Millisecond)
            fmt.Printf("w%d used conn id=%d\n", i, c.ID)
        }(i)
    }
    wg.Wait()
}

package main

import (
    "context"
    "errors"
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

type Conn struct {
    ID       int
    Closed   bool
    LastUsed time.Time
    Broken   bool
}

func (c *Conn) Close() { c.Closed = true }

type Pool struct {
    mu          sync.Mutex
    idle        chan *Conn
    open        int
    max         int
    closed      bool
    dial        func(ctx context.Context) (*Conn, error)
    health      func(*Conn) error
    skipIfFresh time.Duration
}

func NewPool(max int, dial func(context.Context) (*Conn, error), h func(*Conn) error) *Pool {
    return &Pool{
        idle: make(chan *Conn, max), max: max, dial: dial, health: h,
        skipIfFresh: 500 * time.Millisecond,
    }
}

func (p *Pool) Get(ctx context.Context) (*Conn, error) {
    const maxRetries = 3
    for attempt := 0; attempt < maxRetries; attempt++ {
        c, err := p.getOne(ctx)
        if err != nil {
            return nil, err
        }
        // Senior decision: skip health check on hot conns. Check has a
        // cost (a round-trip in real life); a conn used 50ms ago is
        // very likely still alive.
        if time.Since(c.LastUsed) < p.skipIfFresh {
            return c, nil
        }
        if err := p.health(c); err == nil {
            return c, nil
        }
        c.Close()
        p.mu.Lock()
        p.open--
        p.mu.Unlock()
    }
    return nil, errors.New("pool: gave up after retries")
}

func (p *Pool) getOne(ctx context.Context) (*Conn, error) {
    select {
    case c := <-p.idle:
        return c, nil
    default:
    }
    p.mu.Lock()
    if p.open < p.max {
        p.open++
        p.mu.Unlock()
        c, err := p.dial(ctx)
        if err != nil {
            p.mu.Lock()
            p.open--
            p.mu.Unlock()
            return nil, err
        }
        return c, nil
    }
    p.mu.Unlock()
    select {
    case c := <-p.idle:
        return c, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

func (p *Pool) Put(c *Conn) {
    if c == nil || c.Closed || c.Broken {
        if c != nil {
            p.mu.Lock()
            p.open--
            p.mu.Unlock()
        }
        return
    }
    c.LastUsed = time.Now()
    select {
    case p.idle <- c:
    default:
        c.Close()
        p.mu.Lock()
        p.open--
        p.mu.Unlock()
    }
}

var nextID atomic.Int64

func main() {
    p := NewPool(3,
        func(ctx context.Context) (*Conn, error) { return &Conn{ID: int(nextID.Add(1)), LastUsed: time.Now()}, nil },
        func(c *Conn) error {
            if c.Broken {
                return errors.New("broken")
            }
            return nil
        },
    )
    ctx := context.Background()
    c1, _ := p.Get(ctx)
    c1.Broken = true
    c1.LastUsed = time.Now().Add(-2 * time.Second) // force a real check next time
    p.idle <- c1
    p.mu.Lock()
    p.open++ // cheat past Put for the demo
    p.mu.Unlock()
    c2, _ := p.Get(ctx)
    fmt.Println("got fresh:", c2.ID, "(broken one discarded)")
}

package main

import (
    "context"
    "errors"
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

type Conn struct {
    ID        int
    CreatedAt time.Time
    LastUsed  time.Time
    Closed    bool
}

func (c *Conn) Close() { c.Closed = true }

type Config struct {
    Max         int
    MaxLifetime time.Duration
    MaxIdleTime time.Duration
}

type Pool struct {
    mu      sync.Mutex
    idle    chan *Conn
    open    int
    cfg     Config
    closed  bool
    dial    func(ctx context.Context) (*Conn, error)
    stopJan chan struct{}
    janDone chan struct{}
}

func NewPool(cfg Config, dial func(context.Context) (*Conn, error)) *Pool {
    p := &Pool{
        idle: make(chan *Conn, cfg.Max), cfg: cfg, dial: dial,
        stopJan: make(chan struct{}), janDone: make(chan struct{}),
    }
    go p.janitor()
    return p
}

// Senior decision: the janitor sweeps idle conns and closes ones over
// MaxIdleTime or MaxLifetime. It does NOT touch checked-out conns —
// they may be mid-query.
func (p *Pool) janitor() {
    defer close(p.janDone)
    interval := p.cfg.MaxIdleTime / 4
    if interval < time.Second {
        interval = time.Second
    }
    t := time.NewTicker(interval)
    defer t.Stop()
    for {
        select {
        case <-p.stopJan:
            return
        case <-t.C:
            p.sweep()
        }
    }
}

func (p *Pool) sweep() {
    now := time.Now()
    var keep []*Conn
loop:
    for {
        select {
        case c := <-p.idle:
            if now.Sub(c.LastUsed) > p.cfg.MaxIdleTime || now.Sub(c.CreatedAt) > p.cfg.MaxLifetime {
                c.Close()
                p.mu.Lock()
                p.open--
                p.mu.Unlock()
            } else {
                keep = append(keep, c)
            }
        default:
            break loop
        }
    }
    for _, c := range keep {
        p.idle <- c
    }
}

func (p *Pool) Get(ctx context.Context) (*Conn, error) {
    for {
        c, err := p.getOne(ctx)
        if err != nil {
            return nil, err
        }
        // Senior decision: enforce lifetime cap on Get. Cheap, guarantees
        // a hot conn cannot survive past MaxLifetime.
        if time.Since(c.CreatedAt) > p.cfg.MaxLifetime {
            c.Close()
            p.mu.Lock()
            p.open--
            p.mu.Unlock()
            continue
        }
        return c, nil
    }
}

func (p *Pool) getOne(ctx context.Context) (*Conn, error) {
    select {
    case c := <-p.idle:
        return c, nil
    default:
    }
    p.mu.Lock()
    if p.open < p.cfg.Max {
        p.open++
        p.mu.Unlock()
        c, err := p.dial(ctx)
        if err != nil {
            p.mu.Lock()
            p.open--
            p.mu.Unlock()
            return nil, err
        }
        c.CreatedAt = time.Now()
        c.LastUsed = c.CreatedAt
        return c, nil
    }
    p.mu.Unlock()
    select {
    case c := <-p.idle:
        return c, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

func (p *Pool) Put(c *Conn) {
    if c == nil || c.Closed {
        if c != nil {
            p.mu.Lock()
            p.open--
            p.mu.Unlock()
        }
        return
    }
    c.LastUsed = time.Now()
    select {
    case p.idle <- c:
    default:
        c.Close()
        p.mu.Lock()
        p.open--
        p.mu.Unlock()
    }
}

func (p *Pool) Close() {
    p.mu.Lock()
    p.closed = true
    p.mu.Unlock()
    close(p.stopJan)
    <-p.janDone
    close(p.idle)
    for c := range p.idle {
        c.Close()
    }
}

var nextID atomic.Int64

func main() {
    cfg := Config{Max: 3, MaxLifetime: 30 * time.Second, MaxIdleTime: 2 * time.Second}
    p := NewPool(cfg, func(ctx context.Context) (*Conn, error) {
        return &Conn{ID: int(nextID.Add(1))}, nil
    })
    defer p.Close()
    ctx := context.Background()
    for i := 0; i < 3; i++ {
        c, _ := p.Get(ctx)
        fmt.Println("checked out:", c.ID)
        p.Put(c)
    }
    time.Sleep(3500 * time.Millisecond)
    c, _ := p.Get(ctx)
    fmt.Println("after sweep, got:", c.ID, "(old ones swept)")
    p.Put(c)
    _ = errors.New
}