@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,299 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: 並列処理のデザインパターンを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, fork-join, pipeline, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、複雑な問題を並列化可能なサブタスクに分割する手法を学びます。Fork/Join パターンとパイプラインパターンの実装を通じて、並列処理のデザインパターンを理解します。
+
+---
+
+## 第7章: 並列パターン
+
+### データ並列 vs タスク並列
+
+| パターン | 説明 | 例 |
+|----------|------|-----|
+| データ並列 | 同じ操作を複数のデータに適用 | 配列の各要素を2倍 |
+| タスク並列 | 異なる操作を同時に実行 | 入力・計算・出力 |
+
+---
+
+## Fork/Join パターン
+
+問題を分割し、並列に処理した後、結果を統合するパターンです。
+
+### 投票集計の例
+
+```python
+#!/usr/bin/env python3
+
+"""Fork/Join パターンによる投票集計"""
+
+import typing as T
+import random
+from math import ceil
+from threading import Thread
+
+
+class StaffMember(Thread):
+    """投票用紙を集計するスタッフ"""
+
+    def __init__(self, votes: T.List[int]):
+        super().__init__()
+        self.votes = votes
+        self.summary: T.Dict[int, int] = {}
+
+    def run(self) -> None:
+        for vote in self.votes:
+            if vote in self.summary:
+                self.summary[vote] += 1
+            else:
+                self.summary[vote] = 1
+
+
+def count_votes(votes: T.List[int], num_workers: int = 3) -> T.Dict[int, int]:
+    """投票を複数のワーカーで並列集計"""
+    workers = []
+    vote_count = len(votes)
+    votes_per_worker = ceil(vote_count / num_workers)
+
+    # Fork: 投票用紙をワーカーに分配
+    for i in range(num_workers):
+        start = i * votes_per_worker
+        end = start + votes_per_worker
+        pile = votes[start:end]
+        worker = StaffMember(pile)
+        workers.append(worker)
+        worker.start()
+
+    # Join: 全ワーカーの完了を待機
+    for worker in workers:
+        worker.join()
+
+    # 結果の統合
+    total: T.Dict[int, int] = {}
+    for worker in workers:
+        for candidate, count in worker.summary.items():
+            total[candidate] = total.get(candidate, 0) + count
+
+    return total
+
+
+if __name__ == "__main__":
+    # 10万票を生成
+    votes = [random.randint(1, 10) for _ in range(100000)]
+    result = count_votes(votes)
+    print(f"投票結果: {result}")
+```
+
+### Fork/Join の流れ
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "Input" as input
+rectangle "Worker 1" as w1
+rectangle "Worker 2" as w2
+rectangle "Worker 3" as w3
+rectangle "部分結果1" as r1
+rectangle "部分結果2" as r2
+rectangle "部分結果3" as r3
+rectangle "統合結果" as result
+
+input --> w1 : Fork
+input --> w2
+input --> w3
+w1 --> r1
+w2 --> r2
+w3 --> r3
+r1 --> result : Join
+r2 --> result
+r3 --> result
+@enduml
+```
+
+---
+
+## パイプラインパターン
+
+処理をステージに分割し、各ステージを並列に実行するパターンです。
+
+### 洗濯パイプラインの例
+
+```python
+#!/usr/bin/env python3
+
+"""パイプラインパターンによる洗濯処理"""
+
+import time
+from queue import Queue
+from threading import Thread
+
+Washload = str
+
+
+class Washer(Thread):
+    """洗濯機を表すスレッド"""
+
+    def __init__(self, in_queue: Queue, out_queue: Queue):
+        super().__init__()
+        self.in_queue = in_queue
+        self.out_queue = out_queue
+
+    def run(self) -> None:
+        while True:
+            washload = self.in_queue.get()
+            print(f"Washer: washing {washload}...")
+            time.sleep(4)  # 洗濯に4秒
+            self.out_queue.put(washload)
+            self.in_queue.task_done()
+
+
+class Dryer(Thread):
+    """乾燥機を表すスレッド"""
+
+    def __init__(self, in_queue: Queue, out_queue: Queue):
+        super().__init__()
+        self.in_queue = in_queue
+        self.out_queue = out_queue
+
+    def run(self) -> None:
+        while True:
+            washload = self.in_queue.get()
+            print(f"Dryer: drying {washload}...")
+            time.sleep(2)  # 乾燥に2秒
+            self.out_queue.put(washload)
+            self.in_queue.task_done()
+
+
+class Folder(Thread):
+    """たたみ処理を表すスレッド"""
+
+    def __init__(self, in_queue: Queue):
+        super().__init__()
+        self.in_queue = in_queue
+
+    def run(self) -> None:
+        while True:
+            washload = self.in_queue.get()
+            print(f"Folder: folding {washload}...")
+            time.sleep(1)  # たたみに1秒
+            print(f"Folder: {washload} done!")
+            self.in_queue.task_done()
+
+
+class Pipeline:
+    """洗濯パイプライン"""
+
+    def run_concurrently(self) -> None:
+        # キューのセットアップ
+        to_be_washed: Queue = Queue()
+        to_be_dried: Queue = Queue()
+        to_be_folded: Queue = Queue()
+
+        # 洗濯物を投入
+        for i in range(4):
+            to_be_washed.put(f'Washload #{i}')
+
+        # パイプラインを開始
+        Washer(to_be_washed, to_be_dried).start()
+        Dryer(to_be_dried, to_be_folded).start()
+        Folder(to_be_folded).start()
+
+        # 完了を待機
+        to_be_washed.join()
+        to_be_dried.join()
+        to_be_folded.join()
+        print("All done!")
+
+
+if __name__ == "__main__":
+    pipeline = Pipeline()
+    pipeline.run_concurrently()
+```
+
+### パイプラインの流れ
+
+```plantuml
+@startuml
+!theme plain
+title パイプラインパターン
+
+concise "Washer" as washer
+concise "Dryer" as dryer
+concise "Folder" as folder
+
+@0
+washer is "Wash 1"
+
+@4
+washer is "Wash 2"
+dryer is "Dry 1"
+
+@8
+washer is "Wash 3"
+dryer is "Dry 2"
+folder is "Fold 1"
+
+@12
+washer is "Wash 4"
+dryer is "Dry 3"
+folder is "Fold 2"
+
+@16
+washer is {-}
+dryer is "Dry 4"
+folder is "Fold 3"
+
+@20
+dryer is {-}
+folder is "Fold 4"
+
+@24
+folder is {-}
+@enduml
+```
+
+### 逐次処理との比較
+
+| 処理方式 | 4つの洗濯物 |
+|----------|-------------|
+| 逐次処理 | (4+2+1) × 4 = 28秒 |
+| パイプライン | 4+4+4+4 + 2 + 1 = 23秒 |
+
+---
+
+## Queue によるスレッド間通信
+
+`queue.Queue` はスレッドセーフなキューです。
+
+| メソッド | 説明 |
+|----------|------|
+| `put(item)` | アイテムを追加（ブロッキング） |
+| `get()` | アイテムを取得（ブロッキング） |
+| `task_done()` | タスク完了を通知 |
+| `join()` | 全タスク完了を待機 |
+
+---
+
+## 次のステップ
+
+Part V では、同期と排他制御を学びます。レースコンディション、デッドロックなどの問題と、Lock、Semaphore による解決策を理解します。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 7/count_votes/count_votes_concurrent.py](../../../apps/python/Chapter%207/count_votes/count_votes_concurrent.py)
+- [apps/python/Chapter 7/pipeline.py](../../../apps/python/Chapter%207/pipeline.py)

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

@@ -0,0 +1,315 @@
+---
+title: Part V - 同期と排他制御
+description: 並行処理における同期問題と解決策を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, lock, semaphore, deadlock, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、並行処理における同期問題（レースコンディション、デッドロック、ライブロック、スタベーション）と、その解決策（Lock、Semaphore）を学びます。
+
+---
+
+## 第8章: レースコンディションと Lock
+
+### レースコンディションとは
+
+複数のスレッドが共有リソースに同時にアクセスし、結果が実行順序に依存してしまう問題です。
+
+### 銀行口座の例（問題あり）
+
+```python
+#!/usr/bin/env python3
+
+"""レースコンディションが発生する銀行口座"""
+
+import time
+from threading import Thread
+
+
+class UnsyncedBankAccount:
+    """同期なしの銀行口座（危険）"""
+
+    def __init__(self, balance: float = 0):
+        self.balance = balance
+
+    def deposit(self, amount: float) -> None:
+        # この3行の間に他のスレッドが割り込む可能性あり
+        current = self.balance
+        time.sleep(0.001)  # 処理時間をシミュレート
+        self.balance = current + amount
+
+    def withdraw(self, amount: float) -> None:
+        current = self.balance
+        time.sleep(0.001)
+        self.balance = current - amount
+
+
+class ATM(Thread):
+    """ATMスレッド"""
+
+    def __init__(self, bank_account):
+        super().__init__()
+        self.bank_account = bank_account
+
+    def run(self) -> None:
+        for _ in range(100):
+            self.bank_account.deposit(10)
+            self.bank_account.withdraw(10)
+
+
+if __name__ == "__main__":
+    account = UnsyncedBankAccount(balance=1000)
+
+    atms = [ATM(account) for _ in range(5)]
+    for atm in atms:
+        atm.start()
+    for atm in atms:
+        atm.join()
+
+    # 期待: 1000、実際: 予測不能
+    print(f"Final balance: {account.balance}")
+```
+
+### 解決策: Lock を使用
+
+```python
+from threading import Lock
+
+
+class SyncedBankAccount:
+    """Lock で同期した銀行口座"""
+
+    def __init__(self, balance: float = 0):
+        self.balance = balance
+        self.lock = Lock()
+
+    def deposit(self, amount: float) -> None:
+        with self.lock:  # クリティカルセクション
+            current = self.balance
+            time.sleep(0.001)
+            self.balance = current + amount
+
+    def withdraw(self, amount: float) -> None:
+        with self.lock:
+            current = self.balance
+            time.sleep(0.001)
+            self.balance = current - amount
+```
+
+---
+
+## Semaphore（セマフォ）
+
+Semaphore は、同時にアクセスできるスレッド数を制限します。
+
+### 駐車場の例
+
+```python
+#!/usr/bin/env python3
+
+"""セマフォによる駐車場の実装"""
+
+import time
+import random
+import typing as T
+from threading import Thread, Semaphore, Lock
+
+TOTAL_SPOTS = 3  # 駐車スペース数
+
+
+class Garage:
+    """駐車場"""
+
+    def __init__(self) -> None:
+        self.semaphore = Semaphore(TOTAL_SPOTS)
+        self.cars_lock = Lock()
+        self.parked_cars: T.List[str] = []
+
+    def enter(self, car_name: str) -> None:
+        """駐車場に入る"""
+        self.semaphore.acquire()  # スペースを確保
+        with self.cars_lock:
+            self.parked_cars.append(car_name)
+            print(f"{car_name} parked")
+
+    def exit(self, car_name: str) -> None:
+        """駐車場を出る"""
+        with self.cars_lock:
+            self.parked_cars.remove(car_name)
+            print(f"{car_name} leaving")
+        self.semaphore.release()  # スペースを解放
+
+
+def park_car(garage: Garage, car_name: str) -> None:
+    garage.enter(car_name)
+    time.sleep(random.uniform(1, 2))
+    garage.exit(car_name)
+
+
+if __name__ == "__main__":
+    garage = Garage()
+    threads = []
+
+    for i in range(10):
+        t = Thread(target=park_car, args=(garage, f"Car #{i}"))
+        threads.append(t)
+        t.start()
+
+    for t in threads:
+        t.join()
+```
+
+---
+
+## 第9章: デッドロック
+
+### デッドロックとは
+
+複数のスレッドが互いに相手の持つリソースを待ち続け、永遠に進行しない状態です。
+
+### 食事する哲学者問題
+
+```python
+#!/usr/bin/env python3
+
+"""デッドロックが発生する哲学者問題"""
+
+import time
+from threading import Thread, Lock
+
+dumplings = 20
+
+
+class LockWithName:
+    """名前付きLock"""
+    def __init__(self, name: str):
+        self.name = name
+        self.lock = Lock()
+
+    def acquire(self):
+        self.lock.acquire()
+
+    def release(self):
+        self.lock.release()
+
+
+class Philosopher(Thread):
+    def __init__(self, name: str, left: LockWithName, right: LockWithName):
+        super().__init__()
+        self.name = name
+        self.left_chopstick = left
+        self.right_chopstick = right
+
+    def run(self) -> None:
+        global dumplings
+
+        while dumplings > 0:
+            # 左の箸を取る
+            self.left_chopstick.acquire()
+            print(f"{self.left_chopstick.name} grabbed by {self.name}")
+
+            # 右の箸を取ろうとする（デッドロックの原因）
+            self.right_chopstick.acquire()
+            print(f"{self.right_chopstick.name} grabbed by {self.name}")
+
+            dumplings -= 1
+            print(f"{self.name} eats. Left: {dumplings}")
+
+            self.right_chopstick.release()
+            self.left_chopstick.release()
+            time.sleep(0.1)
+
+
+if __name__ == "__main__":
+    chopstick_a = LockWithName("chopstick_a")
+    chopstick_b = LockWithName("chopstick_b")
+
+    # 両方の哲学者が異なる順序で箸を取る → デッドロック
+    p1 = Philosopher("Philosopher #1", chopstick_a, chopstick_b)
+    p2 = Philosopher("Philosopher #2", chopstick_b, chopstick_a)
+
+    p1.start()
+    p2.start()
+```
+
+### デッドロックの条件（4つ全て必要）
+
+1. **相互排除** - リソースは一度に1つのスレッドのみ使用
+2. **保持と待機** - リソースを保持しながら他を待つ
+3. **横取り不可** - 他者からリソースを奪えない
+4. **循環待ち** - 循環的な待ち関係が存在
+
+### 解決策1: リソース順序付け
+
+```python
+if __name__ == "__main__":
+    chopstick_a = LockWithName("chopstick_a")
+    chopstick_b = LockWithName("chopstick_b")
+
+    # 両方の哲学者が同じ順序で箸を取る
+    p1 = Philosopher("Philosopher #1", chopstick_a, chopstick_b)
+    p2 = Philosopher("Philosopher #2", chopstick_a, chopstick_b)
+```
+
+### 解決策2: 仲裁者パターン
+
+```python
+class Waiter:
+    """仲裁者"""
+    def __init__(self):
+        self.mutex = Lock()
+
+    def ask_for_chopsticks(self, left, right):
+        with self.mutex:
+            left.acquire()
+            right.acquire()
+
+    def release_chopsticks(self, left, right):
+        right.release()
+        left.release()
+```
+
+---
+
+## ライブロックとスタベーション
+
+### ライブロック
+
+スレッドが状態を変化させ続けるが、進行しない状態。
+
+### スタベーション
+
+特定のスレッドが長期間リソースを取得できない状態。公平なスケジューリングで解決します。
+
+---
+
+## 同期プリミティブの比較
+
+| プリミティブ | 用途 | 同時アクセス数 |
+|--------------|------|----------------|
+| Lock | 排他制御 | 1 |
+| RLock | 再帰的ロック | 1（同一スレッドは再取得可） |
+| Semaphore | リソース数制限 | N |
+| Event | スレッド間シグナル | N/A |
+| Condition | 条件待機 | N/A |
+
+---
+
+## 次のステップ
+
+Part VI では、ノンブロッキング I/O とイベント駆動プログラミングを学びます。スレッドを使わずに並行処理を実現する方法を理解します。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 8/race_condition/](../../../apps/python/Chapter%208/race_condition/)
+- [apps/python/Chapter 8/semaphore.py](../../../apps/python/Chapter%208/semaphore.py)
+- [apps/python/Chapter 9/deadlock/](../../../apps/python/Chapter%209/deadlock/)