Go sync.Pool·버퍼 재사용 — Put 이후엔 Bytes()도 남의 것이다

package main

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

func main() {
  runtime.GOMAXPROCS(1) // P가 하나여야 매번 같은 결과가 나온다
  made := 0
  pool := sync.Pool{New: func() any { made++; return new(bytes.Buffer) }}

  b := pool.Get().(*bytes.Buffer)
  for gcs := 0; gcs <= 2; gcs++ {
    pool.Put(b)
    for i := 0; i < gcs; i++ {
      runtime.GC()
    }
    got := pool.Get().(*bytes.Buffer)
    fmt.Printf("GC %d번 뒤: 같은 버퍼=%t, New %d번\n", gcs, got == b, made)
    b = got
  }
}

package reuse

import (
  "bytes"
  "io"
  "sync"
)

const maxRetainedCapacity = 64 << 10

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

func encode(b *bytes.Buffer, payload []byte) {
  b.WriteString("data=")
  b.Write(payload)
  b.WriteByte('\n')
}

// 매번 새 버퍼를 쓰는 기준 구현.
func WriteFresh(w io.Writer, payload []byte) error {
  var b bytes.Buffer
  encode(&b, payload)
  _, err := b.WriteTo(w)
  return err
}

// 필요한 용량을 미리 확보하는 개선. 풀은 쓰지 않는다.
func WriteGrown(w io.Writer, payload []byte) error {
  var b bytes.Buffer
  b.Grow(len(payload) + 6)
  encode(&b, payload)
  _, err := b.WriteTo(w)
  return err
}

// 풀에서 빌려 쓰고 반납한다.
func WritePooled(w io.Writer, payload []byte) error {
  b := buffers.Get().(*bytes.Buffer)
  b.Reset()
  defer func() {
    if b.Cap() <= maxRetainedCapacity {
      b.Reset()
      buffers.Put(b)
    }
  }()

  encode(b, payload)
  _, err := b.WriteTo(w)
  return err
}

package main

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

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

// 나쁜 예: 내부 배열을 가리키는 슬라이스를 돌려주고 버퍼를 반납한다.
func encodeBad(name string) []byte {
  b := pool.Get().(*bytes.Buffer)
  b.Reset()
  b.WriteString("user=")
  b.WriteString(name)
  out := b.Bytes() // 복사본이 아니라 내부 배열을 보는 슬라이스다
  pool.Put(b)      // 여기서 사용 권한이 끝난다
  return out
}

// 좋은 예: 반납 전에 독립된 복사본을 만든다.
func encodeGood(name string) []byte {
  b := pool.Get().(*bytes.Buffer)
  b.Reset()
  b.WriteString("user=")
  b.WriteString(name)
  out := append([]byte(nil), b.Bytes()...)
  pool.Put(b)
  return out
}

func main() {
  bad := encodeBad("alice")
  fmt.Printf("반납 직후      : %s\n", bad)
  _ = encodeBad("bob")
  fmt.Printf("다른 요청 뒤   : %s\n", bad)

  good := encodeGood("alice")
  _ = encodeGood("bob")
  fmt.Printf("복사본         : %s\n", good)

  // Reset 은 용량을 유지한다 — Len 이 아니라 Cap 으로 봐야 하는 이유
  var buf bytes.Buffer
  buf.Write(make([]byte, 128<<10))
  fmt.Printf("\n큰 쓰기 직후   : Len=%d Cap=%d\n", buf.Len(), buf.Cap())
  buf.Reset()
  fmt.Printf("Reset 이후     : Len=%d Cap=%d\n", buf.Len(), buf.Cap())
}

package reuse

import (
  "bytes"
  "errors"
  "io"
  "testing"
)

var errWrite = errors.New("쓰기 실패")

type failingWriter struct{}

func (failingWriter) Write(p []byte) (int, error) { return 0, errWrite }

func TestOutput(t *testing.T) {
  for _, size := range []int{0, 32, 128 << 10} {
    payload := bytes.Repeat([]byte("x"), size)
    var fresh, grown, pooled bytes.Buffer
    if err := WriteFresh(&fresh, payload); err != nil {
      t.Fatal(err)
    }
    if err := WriteGrown(&grown, payload); err != nil {
      t.Fatal(err)
    }
    if err := WritePooled(&pooled, payload); err != nil {
      t.Fatal(err)
    }
    want := "data=" + string(payload) + "\n"
    if fresh.String() != want || grown.String() != want || pooled.String() != want {
      t.Fatalf("크기 %d에서 출력이 다르다", size)
    }
  }
}

func TestErrorThenReuse(t *testing.T) {
  if err := WritePooled(failingWriter{}, []byte("이전 값")); !errors.Is(err, errWrite) {
    t.Fatalf("쓰기 에러가 보존되지 않았다: %v", err)
  }
  var out bytes.Buffer
  if err := WritePooled(&out, []byte("다음 값")); err != nil {
    t.Fatal(err)
  }
  if out.String() != "data=다음 값\n" {
    t.Fatalf("출력이 다르다: %q", out.String())
  }
}

func TestConcurrentWrites(t *testing.T) {
  for i := 0; i < 16; i++ {
    t.Run("독립된 출력", func(t *testing.T) {
      t.Parallel()
      for j := 0; j < 100; j++ {
        var out bytes.Buffer
        if err := WritePooled(&out, []byte("hello")); err != nil {
          t.Fatal(err)
        }
        if out.String() != "data=hello\n" {
          t.Fatalf("출력이 섞였다: %q", out.String())
        }
      }
    })
  }
}

func benchLoop(b *testing.B, fn func(io.Writer, []byte) error) {
  payload := bytes.Repeat([]byte("x"), 1024)
  b.ReportAllocs()
  b.ResetTimer()
  for i := 0; i < b.N; i++ {
    if err := fn(io.Discard, payload); err != nil {
      b.Fatal(err)
    }
  }
}

func BenchmarkFresh(b *testing.B)  { benchLoop(b, WriteFresh) }
func BenchmarkGrown(b *testing.B)  { benchLoop(b, WriteGrown) }
func BenchmarkPooled(b *testing.B) { benchLoop(b, WritePooled) }