TCP MSS 与窗口缩放

概念定义

两个握手参数主导批量吞吐。MSS 决定每段最大数据量，由路径 MTU 减去头部推导；窗口缩放是握手选项，把 16 位窗口字段按因子放大，使数 MB 的带宽时延积得以通告。没有缩放时，百兆带宽配 50 毫秒往返的路径根本填不满。

工作机制

两端基于各自 MTU 通告 MSS，中间盒可能改写以强制更小分段。缩放因子在 SYN 中发送一次，最多左移 14 位。接收缓冲区必须真的按结果窗口配置，否则内核把吞吐限制为缓冲区大小除以往返时延。

使用场景

跨区域备份、复制与大对象传输在实践中都是 MSS 与窗口问题。云主机默认缓冲常偏保守，容器网络会悄悄加封装开销触发钳制。应把有效吞吐与理论带宽时延积对比来发现缺口。

常见误区

封装会缩小有效 MSS：端点不计算隧道头时数据包会分片或黑洞丢弃。部分路径丢弃 TCP 选项，退化成无缩放。调大缓冲只帮到发送端拥塞窗口或应用写模式成为限制之前；把吞吐问题当带宽问题诊断是常见弯路。

代码示例

@keyframes fadeIn {
  from { opacity: 0; transform: translateY(20px); }
  to { opacity: 1; transform: translateY(0); }
}

.animate-fade {
  animation: fadeIn 0.3s ease-out forwards;
}

@keyframes pulse {
  0%, 100% { transform: scale(1); }
  50% { transform: scale(1.05); }
}

class CacheNode<K, V> {
  public previous: CacheNode<K, V> | null = null;
  public next: CacheNode<K, V> | null = null;

  public constructor(
    public readonly key: K,
    public value: V,
    public frequency: number,
  ) {}
}

class FrequencyList<K, V> {
  private head: CacheNode<K, V> | null = null;
  private tail: CacheNode<K, V> | null = null;
  public size = 0;

  public addFront(node: CacheNode<K, V>): void {
    node.previous = null;
    node.next = this.head;
    if (this.head !== null) this.head.previous = node;
    this.head = node;
    if (this.tail === null) this.tail = node;
    this.size += 1;
  }

  public remove(node: CacheNode<K, V>): void {
    if (node.previous !== null) node.previous.next = node.next;
    else this.head = node.next;
    if (node.next !== null) node.next.previous = node.previous;
    else this.tail = node.previous;
    node.previous = null;
    node.next = null;
    this.size -= 1;
  }

  public removeLast(): CacheNode<K, V> | null {
    if (this.tail === null) return null;
    const node = this.tail;
    this.remove(node);
    return node;
  }
}

export class LfuCache<K, V> {
  private readonly entries = new Map<K, CacheNode<K, V>>();
  private readonly frequencies = new Map<number, FrequencyList<K, V>>();
  private lowestFrequency = 0;

  public constructor(private readonly capacity: number) {
    if (!Number.isInteger(capacity) || capacity < 1) {
      throw new RangeError("capacity must be a positive integer");
    }
  }

  public get size(): number {
    return this.entries.size;
  }

  public get(key: K): V | undefined {
    const node = this.entries.get(key);
    if (node === undefined) return undefined;
    this.touch(node);
    return node.value;
  }

  public peek(key: K): V | undefined {
    return this.entries.get(key)?.value;
  }

  public put(key: K, value: V): this {
    const existing = this.entries.get(key);
    if (existing !== undefined) {
      existing.value = value;
      this.touch(existing);
      return this;
    }

    if (this.entries.size >= this.capacity) this.evict();
    const node = new CacheNode(key, value, 1);
    this.entries.set(key, node);
    this.listFor(1).addFront(node);
    this.lowestFrequency = 1;
    return this;
  }

  public delete(key: K): boolean {
    const node = this.entries.get(key);
    if (node === undefined) return false;
    this.removeNode(node);
    return true;
  }

  private touch(node: CacheNode<K, V>): void {
    const oldFrequency = node.frequency;
    const oldList = this.frequencies.get(oldFrequency);
    if (oldList === undefined) {
      throw new Error("cache invariant violated");
    }
    oldList.remove(node);
    if (oldList.size === 0) {
      this.frequencies.delete(oldFrequency);
      if (this.lowestFrequency === oldFrequency) {
        this.lowestFrequency = oldFrequency + 1;
      }
    }
    node.frequency = oldFrequency + 1;
    this.listFor(node.frequency).addFront(node);
  }

  private evict(): void {
    const list = this.frequencies.get(this.lowestFrequency);
    if (list === undefined) return;
    const node = list.removeLast();
    if (node === null) return;
    this.entries.delete(node.key);
    if (list.size === 0) this.frequencies.delete(this.lowestFrequency);
  }

  private removeNode(node: CacheNode<K, V>): void {
    const list = this.frequencies.get(node.frequency);
    if (list === undefined) {
      throw new Error("cache invariant violated");
    }
    list.remove(node);
    this.entries.delete(node.key);
    if (list.size === 0) this.frequencies.delete(node.frequency);
  }

  private listFor(frequency: number): FrequencyList<K, V> {
    let list = this.frequencies.get(frequency);
    if (list === undefined) {
      list = new FrequencyList<K, V>();
      this.frequencies.set(frequency, list);
    }
    return list;
  }
}

const cache = new LfuCache<string, number>(2);
cache.put("a", 1).put("b", 2);
console.log(cache.get("a"));
cache.put("c", 3);
console.log(cache.get("b"), cache.peek("a"), cache.get("c"));
cache.put("d", 4);
console.log(cache.get("a"), cache.get("c"), cache.get("d"));
console.log(cache.size);