@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/grokking-concurrency/all/part-6-ch10-11-nonblocking-io.md

@@ -0,0 +1,435 @@
+# Part VI: ノンブロッキング I/O
+
+## 6.1 はじめに
+
+Part V でロックベースの同期を学びましたが、ロックにはデッドロックやコンテキストスイッチのオーバーヘッドが伴います。本章では、**スレッドをブロックせずに I/O を処理する**ノンブロッキング I/O と、それを効率的に管理する**イベントループ**・**Reactor パターン**を学びます。
+
+### なぜノンブロッキング I/O か
+
+| モデル | 接続あたりのコスト | 10,000 接続時 | スケーラビリティ |
+|-------|------------------|-------------|---------------|
+| スレッドパーコネクション | ~1MB（スタック） | ~10GB メモリ | 低い |
+| ノンブロッキング I/O | ~KB（イベント登録） | ~数十 MB | 高い |
+
+従来の「1 接続 = 1 スレッド」モデルでは、大量の同時接続を処理できません。ノンブロッキング I/O は、少数のスレッドで数千の接続を効率的に多重化します。
+
+## 6.2 共通の本質
+
+### ブロッキング vs ノンブロッキング
+
+```
+ブロッキング I/O:
+  Thread → recv() → [ブロック...データ到着を待つ...] → データ処理
+  （スレッドは待機中も占有される）
+
+ノンブロッキング I/O:
+  Thread → recv() → [データなし: すぐ返る] → 他の処理を実行
+                  → [データあり: すぐ返る] → データ処理
+```
+
+### Reactor パターンの構造
+
+```
+                    ┌─────────────────┐
+ Client 1 ─────────┤                 ├──→ Handler A
+ Client 2 ─────────┤   Reactor       ├──→ Handler B
+ Client 3 ─────────┤  (Selector)     ├──→ Handler C
+ Client N ─────────┤                 ├──→ Handler D
+                    └─────────────────┘
+                         ↑
+                    I/O Multiplexer
+                  (select/poll/epoll)
+```
+
+**3 つの構成要素**:
+
+1. **Reactor（ディスパッチャ）** — イベントを検出し、対応するハンドラに振り分ける
+2. **Handler（コールバック）** — 特定のイベントに対する処理を実行
+3. **Multiplexer（多重化）** — OS レベルの I/O 監視（`select`, `poll`, `epoll`, `kqueue`, `IOCP`）
+
+### イベントループのライフサイクル
+
+```
+while running:
+    1. I/O Multiplexer に登録されたソケットを監視
+    2. 準備完了のイベントを取得
+    3. 各イベントに対応するハンドラを呼び出す
+    4. ハンドラ完了後、1 に戻る
+```
+
+## 6.3 言語別実装比較
+
+### I/O 多重化のメカニズム
+
+| 言語 | 低レベル API | 高レベル API | I/O モデル |
+|------|------------|------------|-----------|
+| Python | `select` / `selectors` | `asyncio` | Selector ベース |
+| Java | `Selector` / `Channel` (NIO) | `CompletableFuture` | Channel + Buffer |
+| C# | `Socket.Select()` | `async/await` + `Task` | IOCP ベース |
+| Scala | Java NIO `Selector` | `Future` | JVM Channel |
+| F# | .NET `Socket` | `async { }` ワークフロー | .NET 非同期 |
+| Rust | `mio` (低レベル) | `tokio` (高レベル) | epoll/kqueue |
+| Haskell | GHC I/O Manager | `async` ライブラリ | Green Thread |
+| Clojure | Java NIO | `future` / `core.async` | JVM Channel |
+
+### Reactor パターンの実装
+
+#### 関数型ファースト言語
+
+<details>
+<summary>Haskell 実装（async ライブラリ）</summary>
+
+```haskell
+import Control.Concurrent.Async
+
+-- 非同期 I/O
+handle <- async $ readFile "file.txt"
+doSomethingElse
+content <- wait handle
+
+-- 複数の非同期タスクを並列実行
+downloadAll :: [String] -> IO [String]
+downloadAll urls = mapConcurrently fetchData urls
+
+-- レース: 最初に完了した方を返す
+result <- race fetchFromServerA fetchFromServerB
+```
+
+**特徴**:
+
+- GHC ランタイムが I/O Manager でノンブロッキング I/O を管理
+- `async` / `wait` で明示的にイベントループを書く必要がない
+- Green Thread により、ブロッキング API をそのまま使っても内部的にはノンブロッキング
+- **最も高い抽象度**: 開発者はブロッキング/ノンブロッキングを意識しない
+
+</details>
+
+<details>
+<summary>Clojure 実装（future + promise）</summary>
+
+```clojure
+;; future: 自動的に非同期実行
+(def result (future
+  (Thread/sleep 1000)
+  (+ 1 2)))
+
+@result  ;; => 3（ブロッキング取得）
+
+;; タイムアウト付き
+(deref result 500 :timeout)
+
+;; promise: 明示的に値を配信
+(def p (promise))
+(future
+  (Thread/sleep 100)
+  (deliver p :done))
+@p  ;; => :done
+
+;; 複数の非同期タスク
+(defn fetch-all [urls]
+  (let [futures (doall (map #(future (fetch-url %)) urls))]
+    (map deref futures)))
+```
+
+**特徴**:
+
+- `future` は JVM スレッドプール上で非同期実行
+- `promise` は 1 回だけ値を配信できるコンテナ
+- `deref` でブロッキング取得（タイムアウトオプション付き）
+
+</details>
+
+#### マルチパラダイム言語
+
+<details>
+<summary>Rust 実装（tokio）</summary>
+
+```rust
+use tokio;
+use tokio::time::{sleep, Duration};
+
+#[tokio::main]
+async fn main() {
+    let result = fetch_data("url").await;
+    println!("{}", result);
+}
+
+async fn fetch_data(url: &str) -> String {
+    sleep(Duration::from_secs(1)).await;
+    format!("Data from {}", url)
+}
+
+// 複数タスクの並列実行
+async fn parallel_fetch() -> (String, String, String) {
+    tokio::join!(
+        fetch_data("url1"),
+        fetch_data("url2"),
+        fetch_data("url3"),
+    )
+}
+```
+
+**特徴**:
+
+- **tokio** がイベントループ（Reactor）を提供
+- `async fn` + `.await` でノンブロッキング I/O を記述
+- 内部的に epoll/kqueue を使用
+- ゼロコスト Future: コンパイラがステートマシンを生成
+
+</details>
+
+<details>
+<summary>Scala 実装（Java NIO ラッパー）</summary>
+
+```scala
+import java.nio.channels.{Selector, SocketChannel, SelectionKey}
+
+val selector = Selector.open()
+channel.configureBlocking(false)
+channel.register(selector, SelectionKey.OP_READ)
+
+while true do
+  selector.select()
+  val keys = selector.selectedKeys().iterator()
+  while keys.hasNext do
+    val key = keys.next()
+    keys.remove()
+    if key.isReadable then handleRead(key)
+    if key.isWritable then handleWrite(key)
+```
+
+**特徴**: Java NIO を Scala の式ベース構文で利用。
+
+</details>
+
+<details>
+<summary>F# 実装（Async ワークフロー）</summary>
+
+```fsharp
+// ノンブロッキング読み取り
+let readFileAsync path : Async<string> =
+    async {
+        use reader = new StreamReader(path)
+        let! content = reader.ReadToEndAsync() |> Async.AwaitTask
+        return content
+    }
+
+// 並列実行
+let results =
+    [readFileAsync "a.txt"; readFileAsync "b.txt"; readFileAsync "c.txt"]
+    |> Async.Parallel
+    |> Async.RunSynchronously
+```
+
+**特徴**:
+
+- `async { }` 計算式でノンブロッキング I/O を宣言的に記述
+- `let!` でバインド（中断点）
+- `Async.Parallel` で並列合成
+- C# の `Task` との相互運用が可能
+
+</details>
+
+#### OOP + 並行処理ライブラリ言語
+
+<details>
+<summary>Java 実装（NIO Selector）</summary>
+
+```java
+Selector selector = Selector.open();
+ServerSocketChannel serverChannel = ServerSocketChannel.open();
+serverChannel.configureBlocking(false);
+serverChannel.register(selector, SelectionKey.OP_ACCEPT);
+
+while (true) {
+    selector.select();  // ブロック: イベントが来るまで待機
+    Set<SelectionKey> keys = selector.selectedKeys();
+    Iterator<SelectionKey> iter = keys.iterator();
+
+    while (iter.hasNext()) {
+        SelectionKey key = iter.next();
+        iter.remove();
+
+        if (key.isAcceptable()) handleAccept(key);
+        if (key.isReadable()) handleRead(key);
+        if (key.isWritable()) handleWrite(key);
+    }
+}
+```
+
+**特徴**:
+
+- **NIO (New I/O)**: `Channel` + `Buffer` + `Selector` の三位一体
+- `configureBlocking(false)` でノンブロッキングモードに設定
+- `SelectionKey` がイベント種別（`OP_ACCEPT`, `OP_READ`, `OP_WRITE`）を表す
+- JDK 標準ライブラリのみで実装可能
+
+</details>
+
+<details>
+<summary>C# 実装（async/await）</summary>
+
+```csharp
+// 言語レベルの非同期サポート
+public async Task<string> FetchDataAsync(string url)
+{
+    using var client = new HttpClient();
+    return await client.GetStringAsync(url);
+}
+
+// 複数の非同期タスクを並列実行
+var tasks = urls.Select(url => FetchDataAsync(url));
+var results = await Task.WhenAll(tasks);
+```
+
+**特徴**:
+
+- `async` / `await` が言語機能として組み込み
+- コンパイラがステートマシンを自動生成
+- 内部的に IOCP (I/O Completion Ports) を使用
+- 低レベルの Selector を意識する必要がない
+
+</details>
+
+<details>
+<summary>Python 実装（Selector + Reactor）</summary>
+
+```python
+import selectors
+
+class PizzaReactor:
+    def __init__(self, port):
+        self.selector = selectors.DefaultSelector()
+        self.server_socket = socket.socket()
+        self.server_socket.setblocking(False)
+        self.server_socket.bind(('', port))
+        self.server_socket.listen()
+        self.selector.register(self.server_socket, selectors.EVENT_READ, self._on_accept)
+
+    def _on_accept(self, sock):
+        conn, addr = sock.accept()
+        conn.setblocking(False)
+        self.selector.register(conn, selectors.EVENT_READ, self._on_read)
+
+    def _on_read(self, conn):
+        data = conn.recv(1024)
+        if data:
+            self.selector.modify(conn, selectors.EVENT_WRITE,
+                                 lambda c: self._on_write(c, data.decode()))
+
+    def _on_write(self, conn, message):
+        conn.send(f"Thank you for {message}!\n".encode())
+        self.selector.modify(conn, selectors.EVENT_READ, self._on_read)
+
+    def run(self):
+        while True:
+            events = self.selector.select()
+            for key, mask in events:
+                callback = key.data
+                callback(key.fileobj)
+```
+
+**特徴**:
+
+- `selectors.DefaultSelector` が OS 最適な多重化を自動選択
+- コールバックパターン: `register` → `select` → コールバック呼び出し
+- 状態遷移: ACCEPT → READ → WRITE → READ → ...
+- 最も低レベルな Reactor パターンの実装
+
+</details>
+
+## 6.4 比較分析
+
+### 抽象度のスペクトラム
+
+```
+最高レベル  ┌────────────────────────────────┐
+            │ Haskell: GHC が自動管理        │ ← ブロッキング API で OK
+            │ C#: async/await (言語機能)     │
+            ├────────────────────────────────┤
+高レベル    │ Rust: tokio async/await        │
+            │ F#: async { } ワークフロー      │
+            │ Clojure: future / core.async   │
+            ├────────────────────────────────┤
+中レベル    │ Java: NIO Selector + Channel   │
+            │ Scala: Java NIO ラッパー       │
+            ├────────────────────────────────┤
+低レベル    │ Python: selectors + コールバック │ ← 手動 Reactor 実装
+            └────────────────────────────────┘
+```
+
+### イベントループの利点と欠点
+
+| 利点 | 欠点 |
+|------|------|
+| ロック不要（単一スレッド実行） | コールバック地獄のリスク |
+| 軽量（接続あたりのメモリ最小） | CPU バウンド処理で全体がブロック |
+| スケーラブル（C10K 問題を解決） | デバッグが困難 |
+| 予測可能な実行順序 | 複雑な状態管理 |
+
+### OS レベルの I/O 多重化
+
+| システムコール | OS | 特徴 |
+|-------------|-----|------|
+| `select` | 全 OS | 古典的。FD 数に上限あり（1024） |
+| `poll` | Linux, macOS | `select` の改良。FD 数制限なし |
+| `epoll` | Linux | 高性能。イベント通知方式 |
+| `kqueue` | macOS, BSD | epoll 相当。macOS 標準 |
+| `IOCP` | Windows | 完了通知方式。.NET の基盤 |
+
+各言語のランタイムやライブラリが、OS に応じて最適な多重化を自動選択します。
+
+## 6.5 実践的な選択指針
+
+### 高負荷サーバーに適した言語
+
+**最も適している**:
+
+- **Rust (tokio)** — ゼロコスト async/await + epoll/kqueue 統合。メモリ効率が最高
+- **Java (NIO)** — 成熟した NIO フレームワーク。Netty などの実績あるライブラリ
+
+**生産性が高い**:
+
+- **C#** — 言語レベルの async/await。ASP.NET で大規模 Web サーバーの実績
+- **Haskell** — GHC が自動管理。開発者は非同期を意識しない
+
+**プロトタイピング**:
+
+- **Python** — `asyncio` で素早くプロトタイプ。ただし CPU バウンドには不向き
+- **Clojure** — `core.async` で CSP モデルの非同期設計
+
+### コールバック地獄の回避
+
+| 言語 | 解決策 |
+|------|--------|
+| Python | `asyncio` + `async/await`（Part VII で詳述） |
+| Java | `CompletableFuture` チェーン / Virtual Thread |
+| C# | `async/await`（言語機能） |
+| Rust | `async/await` + `tokio` |
+| Haskell | `do` 記法（モナド合成） |
+| Clojure | `go` ブロック（CSP モデル） |
+| Scala | `for` 内包表記（モナド合成） |
+| F# | `async { }` 計算式 |
+
+## 6.6 まとめ
+
+### 言語横断的な学び
+
+1. **ノンブロッキング I/O は C10K 問題の解法** — 少数スレッドで大量接続を処理
+2. **Reactor パターンは普遍的** — 全言語で同じ設計思想だが、抽象度が異なる
+3. **イベントループはロック不要** — 単一スレッド実行で競合状態を回避
+4. **抽象度と制御のトレードオフ** — Haskell（全自動）vs Python（手動 Reactor）
+5. **OS の多重化 API が基盤** — epoll/kqueue/IOCP を言語ランタイムが抽象化
+
+### 各言語の個別記事
+
+| 言語 | 個別記事 |
+|------|---------|
+| Python | [Part VI - ノンブロッキング I/O](../python/part-6.md) |
+| Java | [Part VI - ノンブロッキング I/O](../java/part-6.md) |
+| C# | [Part VI - ノンブロッキング I/O](../csharp/part-6.md) |
+| Scala | [Part VI - ノンブロッキング I/O](../scala/part-6.md) |
+| F# | [Part VI - ノンブロッキング I/O](../fsharp/part-6.md) |
+| Rust | [Part VI - ノンブロッキング I/O](../rust/part-6.md) |
+| Haskell | [Part VI - ノンブロッキング I/O](../haskell/part-6.md) |
+| Clojure | [Part VI - ノンブロッキング I/O](../clojure/part-6.md) |