4. 对象池与缓存：对象复用模式、functools.lru_cache使用、自定义对象池实现

内存优化的核心思路，说白了就两条：少创建，多复用。

你想想看，Python 里每创建一个对象，都要分配内存、调用构造器、还可能触发 GC。如果对象创建销毁特别频繁，内存占用和 CPU 开销都会飙升。对象池和缓存，就是专门解决这个问题的。

4.1 对象复用模式：为什么需要池？

我刚开始做后端服务时，遇到过一个诡异的问题：一个高并发的 WebSocket 服务，每秒钟要处理几千条消息。每条消息都要创建临时数据结构，处理完就扔掉。结果服务跑了半小时，内存飙到 2GB，GC 停顿越来越频繁，最后直接 OOM。

排查后发现，罪魁祸首就是对象频繁创建。每秒几千个对象，Python 的垃圾回收根本跟不上。解决方案？对象池。

对象复用模式的核心原则：

• 创建成本高的对象才值得池化（比如数据库连接、大数组、复杂数据结构）
• 生命周期短的对象优先考虑池化（临时对象、请求上下文）
• 池化对象要重置状态（拿出来的对象必须清理干净，否则会有脏数据）

4.2 functools.lru_cache：最省心的缓存方案

Python 标准库自带了一个非常好用的缓存工具——functools.lru_cache。它用起来极其简单，但效果惊人。

from functools import lru_cache

@lru_cache(maxsize=128)
def compute_expensive(x, y):
    # 模拟一个耗时的计算
    print(f"计算: {x} * {y}")
    return x * y

# 第一次调用，会执行函数体
print(compute_expensive(3, 5))  # 输出: 计算: 3 * 5 → 15

# 第二次调用，直接返回缓存结果
print(compute_expensive(3, 5))  # 输出: 15（没有打印"计算"）

lru_cache 用的是 LRU（最近最少使用） 淘汰策略。缓存满了，就把最久没用过的条目踢掉。这个策略特别适合「热点数据集中」的场景。

4.3 自定义对象池：手写一个通用池

标准库的缓存虽然好用，但有些场景需要更灵活的控制。比如我要池化数据库连接、线程池、或者自定义的数据结构。这时候就得自己写对象池了。

一个通用的对象池，需要满足几个条件：

• 线程安全：多线程环境下不能出问题
• 容量控制：不能无限增长，要有上限
• 对象重置：借出去的对象还回来时要清理状态
• 超时机制：防止对象被长期占用

import queue
import threading
import time

class ObjectPool:
    """通用对象池"""
    
    def __init__(self, create_func, max_size=10, timeout=5):
        self._create = create_func
        self._max_size = max_size
        self._timeout = timeout
        self._pool = queue.Queue(maxsize=max_size)
        self._lock = threading.Lock()
        self._created = 0
        
    def acquire(self):
        """从池中获取一个对象"""
        try:
            # 尝试从池中获取，超时则创建新对象
            obj = self._pool.get(timeout=self._timeout)
            return obj
        except queue.Empty:
            with self._lock:
                if self._created < self._max_size:
                    self._created += 1
                    return self._create()
                else:
                    # 池满且超时，等待
                    return self._pool.get(timeout=self._timeout)
    
    def release(self, obj):
        """归还对象到池中"""
        self._reset(obj)
        try:
            self._pool.put(obj, timeout=self._timeout)
        except queue.Full:
            # 池满了，丢弃对象
            pass
    
    def _reset(self, obj):
        """重置对象状态（子类可覆盖）"""
        pass
    
    def __enter__(self):
        return self.acquire()
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.release(self._current_obj)

# 创建一个数据库连接池
def create_conn():
    return {"host": "localhost", "port": 3306, "connected": True}

pool = ObjectPool(create_conn, max_size=5)

# 获取连接
with pool as conn:
    print(f"使用连接: {conn}")
# 自动归还

4.4 对象池 vs 缓存：什么时候用哪个？

这两个概念容易混淆。我简单区分一下：

我个人习惯：计算密集型用缓存，IO 密集型用对象池。比如数据库查询结果用缓存，数据库连接用对象池。

4.5 实战：用对象池优化消息处理

回到开头那个 WebSocket 服务的例子。我用对象池重构后，内存占用从 2GB 降到了 800MB，GC 停顿几乎消失。

import json
from collections import deque

class MessageObject:
    """可复用的消息对象"""
    __slots__ = ('type', 'payload', 'timestamp')
    
    def __init__(self):
        self.reset()
    
    def reset(self):
        self.type = None
        self.payload = None
        self.timestamp = 0
    
    def fill(self, msg_type, payload, timestamp):
        self.type = msg_type
        self.payload = payload
        self.timestamp = timestamp
        return self

class MessagePool:
    def __init__(self, size=100):
        self._pool = deque(maxlen=size)
        for _ in range(size):
            self._pool.append(MessageObject())
    
    def acquire(self):
        if self._pool:
            return self._pool.popleft()
        return MessageObject()
    
    def release(self, msg):
        msg.reset()
        self._pool.append(msg)

# 使用
pool = MessagePool(200)

def handle_message(raw_data):
    msg = pool.acquire()
    try:
        data = json.loads(raw_data)
        msg.fill(data['type'], data['payload'], time.time())
        # 处理消息...
        return msg
    finally:
        pool.release(msg)

4.6 避坑指南

对象池和缓存虽然好用，但用不好反而会出问题。我总结几个常见坑：

• 对象泄漏：借出去的对象没归还，池子越来越空。我习惯用 with 语句自动管理。
• 状态污染：归还的对象没重置，下次拿到的是脏数据。一定要在 release 里做清理。
• 缓存膨胀：lru_cache 的 maxsize 设太大，内存被缓存占满。我一般先设小一点，用 cache_info() 观察命中率再调整。
• 线程安全：多线程环境下，对象池必须加锁或用 queue.Queue。我踩过没加锁导致数据错乱的坑。

4.7 本章小结

对象池和缓存，是内存优化的两把利器。对象池适合复用「创建成本高」的对象，缓存适合复用「计算成本高」的结果。用好了，内存占用降一半不是梦。

记住几个关键点：

• 只池化高频创建的对象
• 归还时一定要重置状态
• 缓存要设上限，防止内存泄漏
• 多线程环境注意线程安全