系統設計

1type CallResult = { ok: boolean; ms: number };
2 
3// Full jitter: wait a random time up to an exponentially growing cap.
4function backoffDelay(attempt: number, baseMs: number, capMs: number, random: () => number): number {
5  return random() * Math.min(capMs, baseMs * 2 ** attempt);
6}
7 
8function callWithRetry(call: () => CallResult, retries: number, timeoutMs: number, baseMs: number,
9                       capMs: number, random: () => number, sleep: (ms: number) => void): boolean {
10  for (let attempt = 0; attempt <= retries; attempt++) {
11    const result = call();
12    if (result.ok && result.ms <= timeoutMs) return true;
13    if (attempt < retries) sleep(backoffDelay(attempt, baseMs, capMs, random));
14  }
15  return false;
16}
17 
18class CircuitBreaker {
19  state: "closed" | "open" | "half-open" = "closed";
20  private outcomes: boolean[] = [];
21  private openedAt = 0;
22  private probing = false;
23 
24  constructor(private window = 20, private minCalls = 10, private rate = 0.5, private cooldownMs = 2000) {}
25 
26  allow(now: number): boolean {
27    if (this.state === "open" && now - this.openedAt >= this.cooldownMs) {
28      this.state = "half-open";
29      this.probing = false;
30    }
31    if (this.state === "closed") return true;
32    if (this.state === "half-open" && !this.probing) {
33      this.probing = true;
34      return true;
35    }
36    return false;
37  }
38 
39  record(ok: boolean, now: number): void {
40    if (this.state === "half-open") {
41      this.probing = false;
42      if (ok) { this.state = "closed"; this.outcomes = []; }
43      else { this.state = "open"; this.openedAt = now; }
44      return;
45    }
46    if (this.state !== "closed") return;
47    this.outcomes.push(ok);
48    if (this.outcomes.length > this.window) this.outcomes.shift();
49    const failures = this.outcomes.filter((o) => !o).length;
50    if (this.outcomes.length >= this.minCalls && failures / this.outcomes.length >= this.rate) {
51      this.state = "open";
52      this.openedAt = now;
53      this.outcomes = [];
54    }
55  }
56}
57 
58// Separate pools: one slow dependency can hold at most `limit` threads.
59class Bulkhead {
60  private inUse = 0;
61  constructor(private limit: number) {}
62  tryAcquire(): boolean {
63    if (this.inUse >= this.limit) return false;
64    this.inUse++;
65    return true;
66  }
67  release(): void { this.inUse--; }
68}
69 
70// A bounded queue: refuse new work now rather than serve it too late.
71function admit(queueLength: number, limit: number): boolean {
72  return queueLength < limit;
73}