import sysa = [] 列表对象 refcount = 1b = a # refcount = 2a = None # refcount = 1b = None # refcount = 0 → 对象被立即销毁print(sys.getrefcount(a)) # 注意：getrefcount 本身会增加一次引用

循环引用：两个对象互相指向对方a = []b = []a.append(b) # a 持有 b 的引用b.append(a) # b 持有 a 的引用# 此时 a 和 b 的引用计数都不为 0，但外部已经没有任何变量指向它们了# 引用计数永远无法清理这对"孤儿"

第 0 代（年轻代）：新创建的对象第 1 代（幸存代）：经历一次 GC 仍然存活的对象第 2 代（老年代）：经历多次 GC 仍然存活的对象

import gcprint(gc.get_threshold())

(700, 10, 10)# 第0代对象数量超过 700 时，触发第0代回收# 第1代回收 10 次后，触发第1代回收# 第2代回收 10 次后，触发第2代回收

import gcimport timedef make_garbage():创建大量循环引用，触发 GC objects = [] for i in range(10000): a = [] b = [a] a.append(b) objects.append((a, b)) return objectsprint("创建大量垃圾...")make_garbage()# 手动触发 GC（这次 GC 会有明显停顿）print("触发 GC...")start = time.perf_counter()gc.collect()elapsed = time.perf_counter() - startprint(f"GC 耗时: {elapsed*1000:.2f} ms")

import gcPython 3.14 新增的增量 GC 配置# gc.set_incremental_mode(mode)# mode: 'default' | 'lazy' | 'full'# 激进模式：更快清理，但 CPU 开销更高gc.set_incremental_mode('default')# 延迟模式：最小化停顿，但清理速度慢gc.set_incremental_mode('lazy')# 完整模式：禁用增量，恢复传统行为（向后兼容）gc.set_incremental_mode('full')

import gcPython 3.14 新增stats = gc.get_stats()for gen_stats in stats: print(gen_stats) # {'collections': 123, 'collected': 4567, 'uncollectable': 0, # 'incremental': True, 'pause_total': 0.034, ...} # 'pause_total': 累计 GC 停顿时间（秒）

import gcimport time手动开启增量 GC 后的停顿监控gc.set_incremental_mode('default')last_pause = gc.get_last_gc_pause()if last_pause: print(f"上次 GC 停顿: {last_pause*1000:.3f} ms")# 连续监控多次 GCtotal_pause = 0for _ in range(100): make_garbage() gc.collect() pause = gc.get_last_gc_pause() total_pause += pause if pause else 0print(f"100次GC累计停顿: {total_pause*1000:.2f} ms")print(f"平均每次停顿: {total_pause*1000/100:.3f} ms")

模拟场景：Web 服务处理请求时产生临时对象import gcimport timeimport randomclass RequestHandler: def process(self): # 模拟请求处理：创建大量临时对象 data = [random.random() for _ in range(1000)] result = { 'processed': len(data), 'sum': sum(data), 'nested': {'data': data, 'meta': {'count': len(data)}} } # 创建循环引用 result['_self_ref'] = result return resulthandler = RequestHandler()requests_processed = 0gc_pauses = []# 连续处理 10000 个请求，监控 GC 停顿start_time = time.perf_counter()for i in range(10000): handler.process() requests_processed += 1 # 手动触发 GC 来观察停顿 if i % 500 == 0: before = time.perf_counter() gc.collect() pause = time.perf_counter() - before gc_pauses.append(pause) print(f"请求 #{i}: GC 停顿 {pause*1000:.2f} ms")total_time = time.perf_counter() - start_timeprint(f"\n=== GC 停顿统计 ===")print(f"最大停顿: {max(gc_pauses)1000:.2f} ms")print(f"平均停顿: {sum(gc_pauses)/len(gc_pauses)1000:.2f} ms")print(f"总处理时间: {total_time:.2f} s")print(f"GC 停顿占比: {sum(gc_pauses)/total_time*100:.2f}%")

游戏主循环：每帧必须在 16ms 内完成def game_loop(): while running: events = process_input() update_game_state(events) # 创建大量临时对象 render_frame() # 渲染必须准时 # Python 3.13: GC 可能在这里插入 200ms 停顿 → 掉帧 # Python 3.14: GC 分散成多个 2-5ms 的微小停顿 → 丝滑

import audioop每 20ms 处理一帧音频def process_audio_frame(frame_data): processed = audioop.bias(frame_data, 1, 128) return processed# 300ms 的 GC 停顿 = 15 帧音频丢失

Tick 数据处理：毫秒级延迟敏感def on_tick(tick): # 计算、存储、更新持仓 # 500ms 的 GC 停顿可能导致错过交易信号

Kafka/Pulsar 消费者for message in consumer: process(message) # 创建大量临时对象用于解析 # GC 停顿 → 消费 lag 飙升 → 监控报警

import gc1. 在对象创建密集的代码之前，手动触发 GCdef process_batch(items): gc.collect() # 先清理干净 for item in items: # 处理逻辑 pass gc.collect() # 处理完后再次清理# 2. 减少循环引用的创建class Node: def init(self, value): self.value = value # 旧写法：创建循环引用 # self.parent = None # self.children = [] # 新写法：用 weakref 避免循环引用 import weakref self.parent = None self.children = [] def add_child(self, child): self.children.append(child) child.parent = weakref.ref(self)() # 弱引用，不增加引用计数# 3. 手动控制 GC 时机gc.disable() # 禁用自动 GC# ... 业务逻辑 ...gc.enable() # 手动在合适时机 gc.collect()

import gc如果你的服务是延迟敏感的，启动时设置：gc.set_incremental_mode('default') # 默认增量模式，最佳平衡# 如果追求最低延迟（不在乎清理速度慢）：gc.set_incremental_mode('lazy')# 调优 GC 阈值gc.set_threshold(100, 10, 10) # 更频繁触发，但每次停顿更短

import gc每次请求后检查 GC 健康度def check_gc_health(): stats = gc.get_stats() if stats[0]['pause_total'] > 0.050: # 50ms 阈值 print("WARNING: GC 停顿过高，建议检查对象创建模式")