[G1-Sync] Manual knowledge update

2026-05-09 21:08:02 +09:00
parent f0befc887a
commit 93ec7e9056
363 changed files with 68333 additions and 64 deletions
@@ -0,0 +1,323 @@
+---
+id: cs-backpressure-deep
+title: Backpressure 깊이 — 큐 / Reactive / Token Bucket
+category: Coding
+status: draft
+source_trust_level: B
+verification_status: conceptual
+created_at: 2026-05-09
+updated_at: 2026-05-09
+tags: [cs, backpressure, queue, vibe-coding]
+tech_stack: { language: "TS", applicable_to: ["Backend"] }
+applied_in: []
+aliases: [backpressure, flow control, drop, bounded queue, reactive streams]
+---
+
+# Backpressure Deep
+
+> 빠른 producer + 느린 consumer = 메모리 폭발 / latency. **Bounded queue + drop / block / shed**. Reactive streams 가 표준 framework.
+
+## 📖 핵심 개념
+- 큐: producer-consumer buffer.
+- Bounded: 한도 초과 시 drop / block.
+- Shed: 우선순위 낮은 거 먼저 drop.
+- Reactive Streams: Pull-based + demand signal.
+
+## 💻 코드 패턴
+
+### Unbounded queue (위험)
+```ts
+// ❌ 메모리 폭발
+const queue: Job[] = [];
+producer.on('event', (job) => queue.push(job));
+// consumer 가 느리면 queue 무한 자라남
+```
+
+### Bounded — drop
+```ts
+class BoundedDropQueue<T> {
+  private q: T[] = [];
+  constructor(private max: number) {}
+  
+  push(item: T): boolean {
+    if (this.q.length >= this.max) {
+      // Drop oldest 또는 newest
+      this.q.shift();  // drop oldest
+    }
+    this.q.push(item);
+    return true;
+  }
+}
+```
+
+### Bounded — block
+```ts
+class BoundedBlockingQueue<T> {
+  private q: T[] = [];
+  private waiters: ((v: T) => void)[] = [];
+  
+  constructor(private max: number) {}
+  
+  async push(item: T): Promise<void> {
+    while (this.q.length >= this.max) {
+      await new Promise(r => setTimeout(r, 10));  // backoff
+    }
+    if (this.waiters.length > 0) {
+      this.waiters.shift()!(item);
+    } else {
+      this.q.push(item);
+    }
+  }
+  
+  async pop(): Promise<T> {
+    if (this.q.length > 0) return this.q.shift()!;
+    return new Promise<T>(r => this.waiters.push(r));
+  }
+}
+```
+
+### Backoff producer (자체 throttle)
+```ts
+async function producerLoop() {
+  while (true) {
+    if (queue.length > THRESHOLD) {
+      const wait = Math.min(100 * (queue.length / THRESHOLD), 5000);
+      await sleep(wait);
+      continue;
+    }
+    const job = await fetchJob();
+    queue.push(job);
+  }
+}
+```
+
+### Reactive Streams (Pull-based demand)
+```ts
+// RxJS / Most.js
+import { from, interval } from 'rxjs';
+import { mergeMap, map } from 'rxjs/operators';
+
+interval(10)  // producer
+  .pipe(
+    mergeMap(i => slowAsync(i), 5),  // 동시 5개만 — backpressure
+    map(x => x * 2),
+  )
+  .subscribe(console.log);
+```
+
+→ mergeMap concurrency = backpressure.
+
+### Node Streams (자동)
+```ts
+import { pipeline } from 'node:stream/promises';
+
+await pipeline(
+  source,
+  transform,
+  destination,
+);
+// 각 stream 의 highWaterMark 가 backpressure
+// readable 가 빠르고 writable 가 느리면 — readable pause
+```
+
+```ts
+const writable = new Writable({
+  highWaterMark: 16384,  // 16KB buffer
+  write(chunk, _, cb) {
+    slowProcess(chunk).then(() => cb());
+  },
+});
+
+source.pipe(writable);
+// pipe 가 자동 backpressure
+```
+
+### Drop priority (load shedding)
+```ts
+class PriorityDropQueue {
+  private q: Job[] = [];
+  
+  push(job: Job) {
+    if (this.q.length >= MAX) {
+      // 낮은 priority drop
+      const lowest = this.q.findIndex(j => j.priority < job.priority);
+      if (lowest >= 0) {
+        this.q.splice(lowest, 1);
+        this.q.push(job);
+      }
+      // Job 의 priority 도 낮으면 — drop new job
+    } else {
+      this.q.push(job);
+    }
+    this.q.sort((a, b) => b.priority - a.priority);
+  }
+}
+```
+
+→ 결제 = high, log = low. Overload 시 log drop.
+
+### Adaptive concurrency
+```ts
+// 응답 시간 따라 동시 처리 수 조정
+class AdaptiveExecutor {
+  private concurrency = 10;
+  private latencies: number[] = [];
+  
+  async execute(task: () => Promise<void>) {
+    while (this.active >= this.concurrency) await sleep(10);
+    
+    const t = Date.now();
+    await task();
+    const ms = Date.now() - t;
+    
+    this.latencies.push(ms);
+    if (this.latencies.length > 100) this.latencies.shift();
+    
+    const p95 = percentile(this.latencies, 0.95);
+    if (p95 > 500 && this.concurrency > 1) this.concurrency--;
+    if (p95 < 100) this.concurrency++;
+  }
+}
+```
+
+→ Latency 가 늘면 concurrency 줄이기.
+
+### Token bucket (위 rate limit 문서)
+```ts
+class TokenBucket {
+  private tokens: number;
+  
+  consume(n = 1): boolean {
+    this.refill();
+    if (this.tokens < n) return false;
+    this.tokens -= n;
+    return true;
+  }
+}
+
+// Producer
+if (bucket.consume()) {
+  await emit(event);
+} else {
+  drop();
+}
+```
+
+### Circuit breaker + backpressure
+```ts
+// 다운스트림 fail 시 circuit open → 더 이상 보내지 X
+if (circuit.isOpen()) {
+  drop();
+  return;
+}
+```
+
+→ [[Backend_Circuit_Breaker]].
+
+### Kafka — partition + lag
+```
+Producer 가 빠르면 Kafka partition 의 disk usage 증가.
+Consumer lag 모니터링 + scale up consumer.
+```
+
+```sql
+-- Lag 모니터링
+SELECT topic, partition, current_offset, log_end_offset, lag
+FROM kafka_consumer_groups WHERE group_id = 'my-group';
+```
+
+### Bounded memory 안 큐 정책
+```
+1. Drop newest (FIFO loss)
+2. Drop oldest (LIFO loss)
+3. Drop priority-based
+4. Block producer
+5. Spill to disk (overflow)
+6. Reject (return error)
+```
+
+→ Use case 별 다름.
+
+### Feedback loop (사용자에 알리기)
+```ts
+app.post('/api/job', async (req, res) => {
+  if (queue.length > MAX) {
+    return res.status(503).set('Retry-After', '30').json({
+      error: 'Service overloaded, please retry',
+    });
+  }
+  await queue.push(req.body);
+  res.status(202).json({ status: 'queued' });
+});
+```
+
+→ Client 가 알고 backoff.
+
+### Server health-based load shed
+```ts
+app.use((req, res, next) => {
+  const cpu = await getCPU();
+  if (cpu > 90 && Math.random() < 0.1) {
+    return res.status(503).end();
+  }
+  next();
+});
+```
+
+→ 10% 확률 drop — 급격한 cliff 방지.
+
+### Queue depth limit (별 service)
+```
+Worker 수 N + queue depth M 면 — N + M 가 max in-flight.
+M 너무 큼 = latency 증가 (큐 안 오래 wait).
+M 너무 적음 = drop / reject 자주.
+
+Little's Law: L = λ × W
+- L = 평균 큐 안 작업
+- λ = 도착률
+- W = 평균 처리 시간
+```
+
+→ p99 latency 목표 고려해서 M 결정.
+
+### Async iterator + bounded
+```ts
+async function* boundedProducer<T>(source: AsyncIterable<T>, limit: number) {
+  let inflight = 0;
+  for await (const item of source) {
+    while (inflight >= limit) await sleep(10);
+    inflight++;
+    yield Promise.resolve(item).finally(() => inflight--);
+  }
+}
+```
+
+## 🤔 의사결정 기준
+| 상황 | 정책 |
+|---|---|
+| Latency critical | Bounded + drop |
+| Strong consistency | Bounded + block |
+| Bursty traffic | Token bucket |
+| Different priority | Priority drop |
+| 분산 | Kafka + lag monitoring |
+| Reactive | RxJS / Reactive Streams |
+
+## ❌ 안티패턴
+- **Unbounded queue**: OOM.
+- **Blocking 무 timeout**: deadlock 가능.
+- **Drop 정책 없음**: 무엇이 잃었는지 모름.
+- **Producer 만 throttle — consumer 안 scale**: 큐 늘어남.
+- **Latency 모니터링 X**: 점진적 죽음.
+- **Block producer + caller blocking**: 상위 시스템 다운.
+- **`fast retry` after drop**: thundering herd.
+
+## 🤖 LLM 활용 힌트
+- Bounded queue + drop / block 정책 명시.
+- Circuit breaker + 503 + Retry-After.
+- 큰 처리량 = Kafka + lag monitor.
+- Adaptive concurrency 가 modern.
+
+## 🔗 관련 문서
+- [[Backpressure_Patterns]]
+- [[Backend_Circuit_Breaker]]
+- [[Backend_Rate_Limiting]]