1
package pool
2

3
import "sync"
4

5
// BufferPool 复用 bytes.Buffer，减少 HTTP 处理中的分配
6
var bufPool = sync.Pool{
7
    New: func() any {
8
        // 预分配 4KB 容量
9
        b := make([]byte, 0, 4096)
10
        return &b
11
    },
12
}
13

14
// GetBuffer 从池中获取一个 buffer
15
func GetBuffer() *[]byte {
16
    return bufPool.Get().(*[]byte)
17
}
18

19
// PutBuffer 归还 buffer 到池中
20
func PutBuffer(buf *[]byte) {
21
    // 重置长度但保留容量，下次可直接复用
22
    *buf = (*buf)[:0]
23
    bufPool.Put(buf)
24
}
25

26
// ProcessRequest 演示池化 buffer 的典型用法
27
func ProcessRequest(data []byte) []byte {
28
    buf := GetBuffer()
29
    defer PutBuffer(buf)
30

31
    *buf = append(*buf, data...)
32
    // ... 业务处理 ...
33

34
    // 必须复制结果，因为 buf 会被归还复用
35
    result := make([]byte, len(*buf))
36
    copy(result, *buf)
37
    return result
38
}

1
class ObjectPool<T> {
2
  private pool: T[] = [];
3
  private factory: () => T;
4
  private reset: (obj: T) => void;
5

6
  constructor(
7
    factory: () => T,
8
    reset: (obj: T) => void,
9
    initialSize = 0
10
  ) {
11
    this.factory = factory;
12
    this.reset = reset;
13
    // 预热：提前创建初始对象
14
    for (let i = 0; i < initialSize; i++) {
15
      this.pool.push(factory());
16
    }
17
  }
18

19
  get(): T {
20
    // 池中有空闲对象则复用，否则新建
21
    if (this.pool.length > 0) {
22
      return this.pool.pop()!;
23
    }
24
    return this.factory();
25
  }
26

27
  release(obj: T): void {
28
    // 重置对象状态后放回池中
29
    this.reset(obj);
30
    this.pool.push(obj);
31
  }
32

33
  get size(): number {
34
    return this.pool.length;
35
  }
36
}
37

38
// 使用示例：连接池
39
interface Connection {
40
  id: number;
41
  query(sql: string): string;
42
  reset(): void;
43
}
44

45
const connPool = new ObjectPool<Connection>(
46
  () => ({ id: Math.random(), query: (sql) => `result: ${sql}`, reset() {} }),
47
  (conn) => conn.reset(),
48
  5
49
);