@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokking-concurrency/python/part-6.md

@@ -0,0 +1,297 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: ノンブロッキング I/O とイベント駆動プログラミングを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, non-blocking, event-loop, reactor, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、スレッドを使わずに並行処理を実現するノンブロッキング I/O とイベント駆動プログラミングを学びます。イベントループと Reactor パターンの実装を通じて理解を深めます。
+
+---
+
+## 第10章: ブロッキング vs ノンブロッキング
+
+### ブロッキング I/O の問題
+
+従来のブロッキング I/O では、I/O 操作が完了するまでスレッドがブロックされます。
+
+```python
+# ブロッキング: データが届くまで待機
+data = socket.recv(1024)  # ← ここでブロック
+process(data)
+```
+
+### スレッド・パー・コネクション
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "クライアント" {
+  actor "Client 1" as c1
+  actor "Client 2" as c2
+  actor "Client 3" as c3
+  actor "Client N" as cn
+}
+
+rectangle "スレッド" {
+  rectangle "Thread 1" as t1
+  rectangle "Thread 2" as t2
+  rectangle "Thread 3" as t3
+  rectangle "Thread N" as tn
+}
+
+rectangle "処理" as proc
+
+c1 --> t1
+c2 --> t2
+c3 --> t3
+cn --> tn
+t1 --> proc
+t2 --> proc
+t3 --> proc
+tn --> proc
+@enduml
+```
+
+**問題点:**
+- スレッド作成のオーバーヘッド
+- メモリ消費（スレッドあたり約1MB）
+- コンテキストスイッチのコスト
+
+### ノンブロッキング I/O
+
+I/O 操作が即座に返り、データが準備できていなければ後で再試行します。
+
+```python
+socket.setblocking(False)
+try:
+    data = socket.recv(1024)  # 即座に返る
+except BlockingIOError:
+    # データがまだない
+    pass
+```
+
+---
+
+## 第11章: イベントループと Reactor パターン
+
+### イベントループ
+
+イベントの発生を監視し、対応するハンドラを実行するループです。
+
+```python
+#!/usr/bin/env python3
+
+"""シンプルなイベントループ実装"""
+
+from __future__ import annotations
+from collections import deque
+from time import sleep
+import typing as T
+
+
+class Event:
+    """イベントループで実行可能なイベント"""
+
+    def __init__(self, name: str, action: T.Callable,
+                 next_event: T.Optional[Event] = None) -> None:
+        self.name = name
+        self._action = action
+        self._next_event = next_event
+
+    def execute_action(self) -> None:
+        """イベントのアクションを実行"""
+        self._action(self)
+        if self._next_event:
+            event_loop.register_event(self._next_event)
+
+
+class EventLoop:
+    """イベントを管理し実行するループ"""
+
+    def __init__(self) -> None:
+        self._events: deque[Event] = deque()
+
+    def register_event(self, event: Event) -> None:
+        """イベントを登録"""
+        self._events.append(event)
+
+    def run_forever(self) -> None:
+        """イベントを永続的に処理"""
+        print(f"Queue running with {len(self._events)} events")
+        while True:
+            try:
+                event = self._events.popleft()
+            except IndexError:
+                continue
+            event.execute_action()
+
+
+def knock(event: Event) -> None:
+    print(event.name)
+    sleep(1)
+
+
+def who(event: Event) -> None:
+    print(event.name)
+    sleep(1)
+
+
+if __name__ == "__main__":
+    event_loop = EventLoop()
+
+    # イベントチェーン: knock → who
+    replying = Event("Who's there?", who)
+    knocking = Event("Knock-knock", knock, replying)
+
+    for _ in range(2):
+        event_loop.register_event(knocking)
+
+    event_loop.run_forever()
+```
+
+### 実行結果
+
+```
+Queue running with 2 events
+Knock-knock
+Who's there?
+Knock-knock
+Who's there?
+...
+```
+
+---
+
+## Reactor パターン
+
+I/O イベントの多重化を行うデザインパターンです。
+
+### 構成要素
+
+| コンポーネント | 役割 |
+|----------------|------|
+| Reactor | イベントの多重化と振り分け |
+| Handler | 特定イベントの処理 |
+| Selector | I/O の準備状態を監視 |
+
+### ピザサーバーの例
+
+```python
+#!/usr/bin/env python3
+
+"""Reactor パターンによるピザサーバー"""
+
+import socket
+import selectors
+from collections import deque
+import typing as T
+
+selector = selectors.DefaultSelector()
+orders: T.Deque[socket.socket] = deque()
+
+
+def accept_order(server_socket: socket.socket) -> None:
+    """新規接続を受け付け"""
+    client, addr = server_socket.accept()
+    print(f"Connection from {addr}")
+    client.setblocking(False)
+    selector.register(client, selectors.EVENT_READ, read_order)
+
+
+def read_order(client: socket.socket) -> None:
+    """注文を読み取り"""
+    data = client.recv(1024)
+    if data:
+        print(f"Order received: {data.decode()}")
+        orders.append(client)
+        # 書き込み可能になったら通知を受ける
+        selector.modify(client, selectors.EVENT_WRITE, send_pizza)
+    else:
+        selector.unregister(client)
+        client.close()
+
+
+def send_pizza(client: socket.socket) -> None:
+    """ピザを送信"""
+    if orders:
+        orders.popleft()
+        client.send(b"Here's your pizza!")
+        selector.unregister(client)
+        client.close()
+
+
+def run_server(host: str = 'localhost', port: int = 8000) -> None:
+    """サーバーを実行"""
+    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    server.bind((host, port))
+    server.listen()
+    server.setblocking(False)
+
+    selector.register(server, selectors.EVENT_READ, accept_order)
+    print(f"Pizza server running on {host}:{port}")
+
+    # イベントループ
+    while True:
+        events = selector.select()  # I/O イベントを待機
+        for key, mask in events:
+            callback = key.data
+            callback(key.fileobj)
+
+
+if __name__ == "__main__":
+    run_server()
+```
+
+### selectors モジュール
+
+`selectors` は、I/O 多重化の高レベル API を提供します。
+
+| メソッド | 説明 |
+|----------|------|
+| `register(fd, events, data)` | ファイル記述子を監視登録 |
+| `unregister(fd)` | 監視を解除 |
+| `select(timeout)` | イベントを待機 |
+| `modify(fd, events, data)` | 監視設定を変更 |
+
+### イベントタイプ
+
+| イベント | 説明 |
+|----------|------|
+| `EVENT_READ` | 読み取り可能 |
+| `EVENT_WRITE` | 書き込み可能 |
+
+---
+
+## シングルスレッドの利点
+
+| 利点 | 説明 |
+|------|------|
+| ロック不要 | 共有状態の競合なし |
+| 軽量 | スレッドのオーバーヘッドなし |
+| スケーラブル | 大量接続を効率的に処理 |
+| 予測可能 | 実行順序が明確 |
+
+---
+
+## 次のステップ
+
+Part VII では、Python の `asyncio` を使った非同期プログラミングを学びます。コルーチン、Future、async/await の使い方を理解します。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 10/pizza_server.py](../../../apps/python/Chapter%2010/pizza_server.py)
+- [apps/python/Chapter 11/event_loop.py](../../../apps/python/Chapter%2011/event_loop.py)
+- [apps/python/Chapter 11/pizza_reactor.py](../../../apps/python/Chapter%2011/pizza_reactor.py)

package/lib/assets/docs/article/grokking-concurrency/python/part-7.md

@@ -0,0 +1,314 @@
+---
+title: Part VII - 非同期プログラミング
+description: Python の asyncio を使った非同期プログラミングを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, asyncio, coroutine, future, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、Python の `asyncio` を使った非同期プログラミングを学びます。コルーチン、Future、async/await の仕組みを理解し、効率的な I/O バウンド処理を実装します。
+
+---
+
+## 第12章: コルーチンと非同期
+
+### コルーチンとは
+
+コルーチンは、実行を中断・再開できる関数です。ジェネレータをベースにしています。
+
+### ジェネレータベースのコルーチン
+
+```python
+#!/usr/bin/env python3
+
+"""コルーチンの基本実装"""
+
+from collections import deque
+import typing as T
+
+Coroutine = T.Generator[None, None, int]
+
+
+class EventLoop:
+    def __init__(self) -> None:
+        self.tasks: T.Deque[Coroutine] = deque()
+
+    def add_coroutine(self, task: Coroutine) -> None:
+        """タスクをキューに追加"""
+        self.tasks.append(task)
+
+    def run_coroutine(self, task: Coroutine) -> None:
+        """タスクを1ステップ実行"""
+        try:
+            task.send(None)  # 次の yield まで実行
+            self.add_coroutine(task)  # 未完了なら再登録
+        except StopIteration:
+            print("Task completed")
+
+    def run_forever(self) -> None:
+        """タスクがなくなるまで実行"""
+        while self.tasks:
+            print("Event loop cycle.")
+            self.run_coroutine(self.tasks.popleft())
+
+
+def fibonacci(n: int) -> Coroutine:
+    """フィボナッチ数列をコルーチンで生成"""
+    a, b = 0, 1
+    for i in range(n):
+        a, b = b, a + b
+        print(f"Fibonacci({i}): {a}")
+        yield  # 制御をイベントループに返す
+    return a
+
+
+if __name__ == "__main__":
+    event_loop = EventLoop()
+    event_loop.add_coroutine(fibonacci(5))
+    event_loop.run_forever()
+```
+
+### 実行結果
+
+```
+Event loop cycle.
+Fibonacci(0): 1
+Event loop cycle.
+Fibonacci(1): 1
+Event loop cycle.
+Fibonacci(2): 2
+Event loop cycle.
+Fibonacci(3): 3
+Event loop cycle.
+Fibonacci(4): 5
+Task completed
+```
+
+---
+
+## async/await 構文
+
+Python 3.5 以降では、`async/await` 構文で読みやすくコルーチンを記述できます。
+
+### 基本構文
+
+```python
+import asyncio
+
+
+async def fetch_data(url: str) -> str:
+    """非同期でデータを取得"""
+    print(f"Fetching {url}...")
+    await asyncio.sleep(1)  # I/O 待ちをシミュレート
+    return f"Data from {url}"
+
+
+async def main():
+    # 逐次実行
+    result1 = await fetch_data("url1")
+    result2 = await fetch_data("url2")
+    print(result1, result2)
+
+
+asyncio.run(main())
+```
+
+### 並行実行
+
+```python
+async def main():
+    # 並行実行（gather を使用）
+    results = await asyncio.gather(
+        fetch_data("url1"),
+        fetch_data("url2"),
+        fetch_data("url3"),
+    )
+    print(results)
+
+
+asyncio.run(main())
+```
+
+---
+
+## Future
+
+Future は、まだ完了していない非同期操作の結果を表すオブジェクトです。
+
+### Future の状態
+
+```plantuml
+@startuml
+!theme plain
+
+state Pending
+state Finished
+state Cancelled
+
+Pending --> Finished : 成功
+Pending --> Cancelled : キャンセル
+Finished --> [*] : Result
+Cancelled --> [*] : Exception
+@enduml
+```
+
+### Future の使用例
+
+```python
+import asyncio
+
+
+async def slow_operation() -> str:
+    await asyncio.sleep(2)
+    return "Operation completed"
+
+
+async def main():
+    # タスクを作成（Futureを返す）
+    task = asyncio.create_task(slow_operation())
+
+    print(f"Task done: {task.done()}")  # False
+
+    result = await task
+
+    print(f"Task done: {task.done()}")  # True
+    print(f"Result: {result}")
+
+
+asyncio.run(main())
+```
+
+---
+
+## 非同期ピザサーバー
+
+```python
+#!/usr/bin/env python3
+
+"""asyncio を使った非同期ピザサーバー"""
+
+import asyncio
+
+
+async def handle_client(reader: asyncio.StreamReader,
+                        writer: asyncio.StreamWriter) -> None:
+    """クライアント処理"""
+    addr = writer.get_extra_info('peername')
+    print(f"Connection from {addr}")
+
+    # 注文を読み取り
+    data = await reader.read(1024)
+    order = data.decode()
+    print(f"Order received: {order}")
+
+    # ピザを作る（非同期で待機）
+    await asyncio.sleep(2)
+
+    # ピザを送信
+    writer.write(b"Here's your pizza!")
+    await writer.drain()
+
+    writer.close()
+    await writer.wait_closed()
+
+
+async def run_server(host: str = 'localhost', port: int = 8000) -> None:
+    """サーバーを起動"""
+    server = await asyncio.start_server(
+        handle_client, host, port)
+
+    addr = server.sockets[0].getsockname()
+    print(f"Pizza server running on {addr}")
+
+    async with server:
+        await server.serve_forever()
+
+
+if __name__ == "__main__":
+    asyncio.run(run_server())
+```
+
+---
+
+## asyncio の主要 API
+
+### タスク管理
+
+| API | 説明 |
+|-----|------|
+| `asyncio.run(coro)` | イベントループを作成して実行 |
+| `asyncio.create_task(coro)` | タスクをスケジュール |
+| `asyncio.gather(*coros)` | 複数のコルーチンを並行実行 |
+| `asyncio.wait(tasks)` | タスク完了を待機 |
+
+### 同期プリミティブ
+
+| API | 説明 |
+|-----|------|
+| `asyncio.Lock()` | 非同期ロック |
+| `asyncio.Semaphore(n)` | 非同期セマフォ |
+| `asyncio.Event()` | 非同期イベント |
+| `asyncio.Queue()` | 非同期キュー |
+
+### I/O
+
+| API | 説明 |
+|-----|------|
+| `asyncio.sleep(delay)` | 非同期スリープ |
+| `asyncio.open_connection()` | TCP 接続を開く |
+| `asyncio.start_server()` | TCP サーバーを開始 |
+
+---
+
+## 使い分けの指針
+
+| シナリオ | 推奨 |
+|----------|------|
+| I/O バウンド（ネットワーク、ファイル） | asyncio |
+| CPU バウンド | multiprocessing |
+| 混合 | asyncio + ProcessPoolExecutor |
+
+### 混合の例
+
+```python
+import asyncio
+from concurrent.futures import ProcessPoolExecutor
+
+
+def cpu_bound_task(n: int) -> int:
+    """CPU を使う処理"""
+    return sum(i * i for i in range(n))
+
+
+async def main():
+    loop = asyncio.get_event_loop()
+
+    with ProcessPoolExecutor() as pool:
+        # CPU バウンドタスクをプロセスプールで実行
+        result = await loop.run_in_executor(
+            pool, cpu_bound_task, 10000000)
+        print(f"Result: {result}")
+
+
+asyncio.run(main())
+```
+
+---
+
+## 次のステップ
+
+Part VIII では、MapReduce パターンと分散並列処理を学びます。大規模データを複数のワーカーで並列処理する手法を理解します。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 12/coroutine.py](../../../apps/python/Chapter%2012/coroutine.py)
+- [apps/python/Chapter 12/future_burger.py](../../../apps/python/Chapter%2012/future_burger.py)
+- [apps/python/Chapter 12/asynchronous_pizza/](../../../apps/python/Chapter%2012/asynchronous_pizza/)