refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게 [공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류. 문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인). - Topic_Programming → Domain_Programming (내부 구조 보존) - Topic_Graphic → Domain_Design - Topic_Business → Domain_Product - Topic_General → Domain_General - _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning), Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing) - 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서) - 빈 폴더 정리 (memory/procedures) - 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -0,0 +1,190 @@
+---
+id: wiki-2026-0508-concurrent-programming
+title: Concurrent Programming
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [Concurrency, Multithreading, Async Programming]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.9
+verification_status: applied
+tags: [programming, concurrency, parallelism, systems]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: Go, Rust, Python, JavaScript
+  framework: tokio, asyncio, goroutines
+---
+
+# Concurrent Programming
+
+## 매 한 줄
+> **"매 concurrency 매 task 의 interleaving — parallelism 의 simultaneous 와 별개"**. Hoare CSP, Hewitt Actor 의 lineage. 2026 매 Rust async, Go goroutines, Java virtual threads (Project Loom GA), Python free-threaded mode 매 mainstream.
+
+## 매 핵심
+
+### 매 Concurrency vs Parallelism
+- **Concurrency**: 매 dealing-with-many things at once (composition).
+- **Parallelism**: 매 doing-many things at once (execution).
+- 매 concurrent 코드 매 single-core 매 still concurrent. 매 parallel 매 multi-core required.
+
+### 매 Primitives
+- **Threads / processes**: 매 OS-level. Heavyweight.
+- **Coroutines / fibers / virtual threads**: 매 user-mode lightweight.
+- **Async / await**: 매 cooperative scheduling.
+- **Channels**: 매 message passing (Go, Rust mpsc).
+- **Mutex / RWLock / Semaphore**: 매 shared-memory sync.
+- **Atomic**: 매 lock-free primitive.
+
+### 매 응용
+1. Web server: 매 1 connection-per-virtual-thread (Loom) / async (tokio).
+2. Pipeline: 매 channel-based fan-out / fan-in.
+3. Actor system: 매 isolation per actor + supervision (Erlang/Elixir, Akka).
+
+## 💻 패턴
+
+### Go: goroutine + channel
+```go
+package main
+
+import "fmt"
+
+func worker(id int, jobs <-chan int, results chan<- int) {
+    for j := range jobs {
+        results <- j * 2
+    }
+    fmt.Println("worker", id, "done")
+}
+
+func main() {
+    jobs := make(chan int, 100)
+    results := make(chan int, 100)
+    for w := 1; w <= 3; w++ {
+        go worker(w, jobs, results)
+    }
+    for j := 1; j <= 9; j++ { jobs <- j }
+    close(jobs)
+    for r := 1; r <= 9; r++ { <-results }
+}
+```
+
+### Rust: tokio + select!
+```rust
+use tokio::{select, time::{sleep, Duration}};
+
+#[tokio::main]
+async fn main() {
+    let task1 = async { sleep(Duration::from_millis(100)).await; "fast" };
+    let task2 = async { sleep(Duration::from_millis(200)).await; "slow" };
+    select! {
+        v = task1 => println!("got {v}"),
+        v = task2 => println!("got {v}"),
+    }
+}
+```
+
+### Java 21+: virtual threads
+```java
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+    IntStream.range(0, 10_000).forEach(i ->
+        executor.submit(() -> {
+            Thread.sleep(Duration.ofSeconds(1));
+            return i;
+        }));
+}  // 10k virtual threads, ~negligible memory
+```
+
+### Python: asyncio TaskGroup (3.11+)
+```python
+import asyncio
+import httpx
+
+async def fetch(client, url):
+    r = await client.get(url)
+    return r.status_code
+
+async def main():
+    async with httpx.AsyncClient() as client:
+        async with asyncio.TaskGroup() as tg:
+            tasks = [tg.create_task(fetch(client, u)) for u in URLS]
+        results = [t.result() for t in tasks]
+```
+
+### Rust: structured concurrency (tokio JoinSet)
+```rust
+use tokio::task::JoinSet;
+let mut set = JoinSet::new();
+for url in urls { set.spawn(fetch(url)); }
+while let Some(res) = set.join_next().await {
+    println!("{:?}", res?);
+}
+```
+
+### Lock-free atomic counter
+```rust
+use std::sync::atomic::{AtomicU64, Ordering};
+static COUNTER: AtomicU64 = AtomicU64::new(0);
+
+fn bump() -> u64 {
+    COUNTER.fetch_add(1, Ordering::Relaxed)
+}
+```
+
+### Actor pattern (Elixir)
+```elixir
+defmodule Counter do
+  use GenServer
+  def start_link(_), do: GenServer.start_link(__MODULE__, 0, name: __MODULE__)
+  def init(s), do: {:ok, s}
+  def handle_call(:inc, _, s), do: {:reply, s+1, s+1}
+end
+```
+
+### Backpressure with bounded channel
+```go
+sem := make(chan struct{}, 10)  // max 10 concurrent
+for _, url := range urls {
+    sem <- struct{}{}
+    go func(u string) { defer func(){ <-sem }(); fetch(u) }(url)
+}
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| I/O-bound, 10k+ connections | Async (tokio, asyncio, Loom) |
+| CPU-bound, multi-core | Threads / rayon (Rust) |
+| Pipeline, multi-stage | Channels (Go, Rust mpsc) |
+| Isolation + fault tolerance | Actors (Elixir, Akka) |
+| Shared mutable state | Mutex + minimize critical section |
+| Hot counter | Atomic, no lock |
+
+**기본값**: structured concurrency + bounded channel + cancellation propagation.
+
+## 🔗 Graph
+- 변형: [[Async Programming]]
+- 응용: [[Distributed Systems]]
+
+## 🤖 LLM 활용
+**언제**: 매 concurrent code review 의 race-condition spotting, 매 deadlock-pattern detection, 매 channel-pattern translation.
+**언제 X**: 매 subtle memory-ordering bug — 매 formal verification (TLA+, loom) 의 사용.
+
+## ❌ 안티패턴
+- **Shared mutable state without sync**: 매 race condition. UB in C++/Rust.
+- **Mutex in hot path**: 매 contention 의 serialization. 매 atomic / per-thread state.
+- **Unbounded goroutine spawn**: 매 OOM. 매 bounded pool / semaphore.
+- **Sync I/O in async function**: 매 single blocked task → 매 entire executor stall.
+- **Lock ordering inconsistent**: 매 deadlock. 매 always same order.
+- **Cancellation 의 ignore**: 매 dangling task / resource leak.
+
+## 🧪 검증 / 중복
+- Verified (Hoare _Communicating Sequential Processes_, Go Memory Model 2022, Rust Async Book, JEP 444 (Java Virtual Threads), Python PEP 703).
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — primitives, Go/Rust/Java/Python pattern, anti-patterns |