@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,296 +0,0 @@
----
-type: Article
-title: "Part VI - ノンブロッキング I/O"
-description: "ノンブロッキング I/O とイベント駆動プログラミングを学ぶ"
-tags: [article, grokking-concurrency, python, concurrency, non-blocking, event-loop, reactor]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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 11/event_loop.py`
-- `apps/python/Chapter 11/pizza_reactor.py`

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

@@ -1,313 +0,0 @@
----
-type: Article
-title: "Part VII - 非同期プログラミング"
-description: "Python の asyncio を使った非同期プログラミングを学ぶ"
-tags: [article, grokking-concurrency, python, concurrency, asyncio, coroutine, future]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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 12/future_burger.py`
-- `apps/python/Chapter 12/asynchronous_pizza/`