垃圾回收机制对设计模式的影响

垃圾回收机制与设计模式的关系

JavaScript的垃圾回收机制通过自动管理内存释放，直接影响设计模式的实现方式。内存管理的自动化特性让开发者无需手动处理对象销毁，但也带来了一些特殊考量。闭包、缓存、对象池等模式与垃圾回收机制存在深度交互，理解这种关系能帮助开发者写出更高效、更少内存泄漏的代码。

闭包模式中的变量保留

闭包会阻止外部函数变量的垃圾回收，即使外部函数已执行完毕。这种特性既是优势也是陷阱：

function createCounter() {
  let count = 0; // 不会被回收
  return function() {
    count++;
    console.log(count);
  };
}
const counter = createCounter();
counter(); // 1
counter(); // 2

在这个计数器实现中，count变量被内部函数引用而保留在内存中。如果滥用这种特性，可能导致意外内存泄漏：

function setupHugeData() {
  const bigData = new Array(1000000).fill('*'); // 占用大量内存
  return function() {
    // 即使只使用bigData的一小部分
    console.log(bigData[0]);
  };
}
const processor = setupHugeData();

单例模式的内存管理

单例模式创建的对象会持续存在于内存中，垃圾回收器永远不会处理它们：

class DatabaseConnection {
  constructor() {
    if (DatabaseConnection.instance) {
      return DatabaseConnection.instance;
    }
    this.connection = createConnection();
    DatabaseConnection.instance = this;
  }
}

这种永久驻留特性适合数据库连接等重量级资源，但需要谨慎评估必要性。对于临时性数据，可以考虑弱引用方案：

const weakRefSingleton = new WeakRef(createExpensiveObject());
function getInstance() {
  let instance = weakRefSingleton.deref();
  if (!instance) {
    instance = createExpensiveObject();
    weakRefSingleton = new WeakRef(instance);
  }
  return instance;
}

观察者模式中的引用问题

观察者模式中未正确移除观察者会导致内存泄漏：

class Subject {
  constructor() {
    this.observers = [];
  }
  addObserver(obs) {
    this.observers.push(obs);
  }
  // 必须显式实现removeObserver
}

更安全的实现方式使用WeakMap避免强引用：

const observers = new WeakMap();
class ModernSubject {
  constructor() {
    observers.set(this, new Set());
  }
  addObserver(obs) {
    observers.get(this).add(obs);
  }
  // 观察者被垃圾回收时自动移除
}

工厂模式与对象复用

垃圾回收压力会影响工厂模式的设计决策。频繁创建销毁对象时，可考虑对象池技术：

class ParticlePool {
  constructor(size) {
    this.pool = Array(size).fill().map(() => new Particle());
  }
  acquire() {
    return this.pool.find(p => !p.active) || new Particle();
  }
  release(particle) {
    particle.reset();
  }
}

对于轻量级对象，现代JavaScript引擎的垃圾回收效率可能高于对象池维护成本，需要进行性能测试。

装饰器模式与临时对象

装饰器模式产生的包装对象会增加垃圾回收频率：

function withLogging(fn) {
  return function(...args) {
    console.log('Calling', fn.name);
    return fn.apply(this, args);
  };
}

高频调用时可能产生大量短期存在的装饰器函数。对于性能敏感场景，可改用原型链装饰：

function decorateWithLogging(klass, methodName) {
  const original = klass.prototype[methodName];
  klass.prototype[methodName] = function(...args) {
    console.log('Calling', methodName);
    return original.apply(this, args);
  };
}

策略模式与函数对象

JavaScript中函数作为一等公民，策略模式实现会产生大量函数对象：

const strategies = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b
};

长期存在的策略对象可能占用内存，对于临时策略可改用函数工厂：

function createStrategy(type) {
  return type === 'add' 
    ? (a, b) => a + b
    : (a, b) => a - b;
}

代理模式与内存开销

Proxy对象会阻止目标对象被回收，使用时需注意生命周期：

let target = { data: 'important' };
const proxy = new Proxy(target, {
  get(obj, prop) {
    return obj[prop];
  }
});
// 即使target=null，原始对象仍被proxy保留

对于大型对象，可考虑在代理中改用弱引用：

const proxyWithWeakRef = new Proxy(new WeakRef(target), {
  get(weakRef, prop) {
    const obj = weakRef.deref();
    return obj ? obj[prop] : undefined;
  }
});

享元模式的内在状态

享元模式通过共享减少对象数量，与垃圾回收机制形成互补：

class TreeType {
  constructor(name, color) {
    this.name = name;
    this.color = color;
  }
}
class TreeFactory {
  static types = new Map();
  static getType(name, color) {
    const key = `${name}_${color}`;
    if (!this.types.has(key)) {
      this.types.set(key, new TreeType(name, color));
    }
    return this.types.get(key);
  }
}

注意长期存在的享元对象可能成为内存热点，需要合理控制缓存大小。

备忘录模式的状态存储

备忘录模式保存的对象状态可能意外保留引用链：

class Editor {
  constructor() {
    this.content = '';
  }
  createSnapshot() {
    return new EditorSnapshot(this, this.content);
  }
}
class EditorSnapshot {
  constructor(editor, content) {
    // 保留editor引用可能导致内存泄漏
    this.editor = editor;
    this.content = content;
  }
}

改进方案只存储必要数据：

class SafeEditorSnapshot {
  constructor(content) {
    this.content = content;
  }
}

访问者模式与对象图

访问复杂对象结构时，访问者模式可能临时增加内存压力：

class Visitor {
  visitComposite(composite) {
    composite.children.forEach(child => {
      child.accept(this); // 递归调用创建大量调用栈
    });
  }
}

对于深度结构，可改用迭代器模式减少内存占用：

class IterativeVisitor {
  visitComposite(composite) {
    const stack = [composite];
    while (stack.length) {
      const current = stack.pop();
      // 处理当前节点
      stack.push(...current.children);
    }
  }
}

垃圾回收友好的代码实践

某些编码习惯能更好地配合垃圾回收机制：

1. 及时断开DOM引用：

// 不推荐
const elements = document.querySelectorAll('.item');
// 推荐按需查询
function processItem() {
  const element = document.querySelector('.current-item');
  // 使用后立即解除引用
}

2. 谨慎使用全局缓存：

// 潜在问题
const cache = {};
function getData(id) {
  if (!cache[id]) {
    cache[id] = fetchData(id);
  }
  return cache[id];
}

// 改进方案
const cache = new Map();
function getData(id) {
  if (cache.size > 100) cache.clear();
  // ...
}

3. 事件监听器的管理：

// 危险做法
element.addEventListener('click', () => {
  // 回调函数持有外部引用
});

// 更安全做法
function handleClick() { /*...*/ }
element.addEventListener('click', handleClick);
// 需要时移除
element.removeEventListener('click', handleClick);