@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,418 @@
+---
+title: Part II - プロセスとスレッド
+description: OS レベルの並行処理の基本単位を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, process, thread, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、OS レベルの並行処理の基本単位であるプロセスとスレッドを学びます。Python での実装方法と、スレッドプール、プロセス間通信（IPC）についても解説します。
+
+---
+
+## 第4章: プロセスとスレッドの基礎
+
+### プロセスとは
+
+プロセスは、実行中のプログラムのインスタンスです。独自のメモリ空間、ファイルハンドル、その他のリソースを持ちます。
+
+### スレッドとは
+
+スレッドは、プロセス内の実行単位です。同じプロセス内のスレッドはメモリ空間を共有します。
+
+### プロセス vs スレッド
+
+| 特徴 | プロセス | スレッド |
+|------|----------|----------|
+| メモリ | 独立 | 共有 |
+| 作成コスト | 高い | 低い |
+| 通信 | IPC が必要 | 直接共有可能 |
+| 安全性 | 高い | 競合の可能性 |
+| GIL の影響 | なし | あり |
+
+---
+
+### スレッドの作成と実行
+
+```python
+#!/usr/bin/env python3
+
+"""スレッドの基本的な使い方"""
+
+import os
+import time
+import threading
+from threading import Thread
+
+
+def cpu_waster(i: int) -> None:
+    """時間のかかる処理をシミュレート"""
+    name = threading.current_thread().name
+    print(f"{name} doing {i} work")
+    time.sleep(3)
+
+
+def display_threads() -> None:
+    """現在のスレッド情報を表示"""
+    print("-" * 10)
+    print(f"Current process PID: {os.getpid()}")
+    print(f"Thread Count: {threading.active_count()}")
+    print("Active threads:")
+    for thread in threading.enumerate():
+        print(thread)
+
+
+def main(num_threads: int) -> None:
+    display_threads()
+
+    print(f"Starting {num_threads} CPU wasters...")
+    for i in range(num_threads):
+        # スレッドの作成と開始
+        thread = Thread(target=cpu_waster, args=(i,))
+        thread.start()
+
+    display_threads()
+
+
+if __name__ == "__main__":
+    num_threads = 5
+    main(num_threads)
+```
+
+#### 実行結果
+
+```
+----------
+Current process PID: 12345
+Thread Count: 1
+Active threads:
+<_MainThread(MainThread, started 140234567890)>
+Starting 5 CPU wasters...
+Thread-1 doing 0 work
+Thread-2 doing 1 work
+Thread-3 doing 2 work
+Thread-4 doing 3 work
+Thread-5 doing 4 work
+----------
+Current process PID: 12345
+Thread Count: 6
+Active threads:
+<_MainThread(MainThread, started 140234567890)>
+<Thread(Thread-1, started 140234567891)>
+...
+```
+
+---
+
+### プロセスのライフサイクル
+
+```python
+#!/usr/bin/env python3
+
+"""プロセスのライフサイクル"""
+
+import time
+from multiprocessing import Process
+
+
+class Worker(Process):
+    def run(self) -> None:
+        print("Worker started...")
+        time.sleep(3)
+        print("Worker is done.")
+
+
+def main() -> None:
+    print("Boss requesting Worker's help.")
+    worker = Worker()
+    print(f"\tWorker alive?: {worker.is_alive()}")  # False
+
+    print("Boss tells Worker to start.")
+    worker.start()
+    print(f"\tWorker alive?: {worker.is_alive()}")  # True
+
+    print("Boss goes for coffee.")
+    time.sleep(0.5)
+    print(f"\tWorker alive?: {worker.is_alive()}")  # True
+
+    print("Boss patiently waits for Worker to finish and join...")
+    worker.join()  # ワーカーの完了を待機
+    print(f"\tWorker alive?: {worker.is_alive()}")  # False
+
+    print("Boss and Worker are both done!")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+#### プロセスの状態遷移
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+state Created
+state Started
+state Running
+state Finished
+
+Created --> Started : start()
+Started --> Running : 実行開始
+Running --> Finished : 完了
+
+note bottom of Started : is_alive() == True
+note bottom of Running : is_alive() == True
+note bottom of Finished : is_alive() == False
+@enduml
+```
+
+---
+
+## 第5章: スレッドプールと IPC
+
+### スレッドプールの実装
+
+スレッドプールは、事前に作成したスレッドを再利用してタスクを処理します。
+
+```python
+#!/usr/bin/env python3
+
+"""シンプルなスレッドプール実装"""
+
+import time
+import queue
+import typing as T
+from threading import Thread, current_thread
+
+Callback = T.Callable[..., None]
+Task = T.Tuple[Callback, T.Any, T.Any]
+
+
+class Worker(Thread):
+    """タスクキューからタスクを取得して実行するワーカー"""
+    def __init__(self, tasks: queue.Queue[Task]):
+        super().__init__()
+        self.tasks = tasks
+
+    def run(self) -> None:
+        while True:
+            func, args, kwargs = self.tasks.get()
+            try:
+                func(*args, **kwargs)
+            except Exception as e:
+                print(e)
+            self.tasks.task_done()
+
+
+class ThreadPool:
+    """タスクキューを消費するスレッドのプール"""
+    def __init__(self, num_threads: int):
+        self.tasks: queue.Queue = queue.Queue(num_threads)
+        self.num_threads = num_threads
+
+        # 長時間稼働するスレッドを作成
+        for _ in range(self.num_threads):
+            worker = Worker(self.tasks)
+            worker.daemon = True
+            worker.start()
+
+    def submit(self, func: Callback, *args, **kwargs) -> None:
+        """タスクをキューに追加"""
+        self.tasks.put((func, args, kwargs))
+
+    def wait_completion(self) -> None:
+        """全タスクの完了を待機"""
+        self.tasks.join()
+
+
+def cpu_waster(i: int) -> None:
+    name = current_thread().name
+    print(f"{name} doing {i} work")
+    time.sleep(3)
+
+
+def main() -> None:
+    pool = ThreadPool(num_threads=5)
+    for i in range(20):
+        pool.submit(cpu_waster, i)
+
+    print("All work requests sent")
+    pool.wait_completion()
+    print("All work completed")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+### 標準ライブラリのスレッドプール
+
+Python の `concurrent.futures` モジュールを使うと、より簡単にスレッドプールを利用できます。
+
+```python
+from concurrent.futures import ThreadPoolExecutor
+import os
+
+def cpu_waster(i: int) -> str:
+    name = current_thread().name
+    print(f"{name} doing Task {i}")
+    time.sleep(3)
+    return f"Task {i} completed"
+
+
+def main() -> None:
+    with ThreadPoolExecutor(
+        max_workers=os.cpu_count(),
+        thread_name_prefix="Pool_Thread"
+    ) as pool:
+        tasks = []
+        for i in range(20):
+            tasks.append(pool.submit(cpu_waster, i))
+
+        for task in tasks:
+            print(task.result())
+
+
+if __name__ == "__main__":
+    main()
+```
+
+---
+
+### 並列パスワードクラッキング
+
+Part I で学んだ逐次処理版を、マルチプロセスで並列化します。
+
+```python
+#!/usr/bin/env python3
+
+"""パスワードクラッキング（並列処理版）"""
+
+import os
+import math
+import time
+import typing as T
+import hashlib
+from multiprocessing import Pool
+
+ChunkRange = T.Tuple[int, int]
+
+
+def get_combinations(*, length: int, min_number: int = 0,
+                     max_number: int = None) -> T.List[str]:
+    """パスワード組み合わせを生成"""
+    combinations = []
+    if not max_number:
+        max_number = int(math.pow(10, length) - 1)
+
+    for i in range(min_number, max_number + 1):
+        str_num = str(i)
+        zeros = "0" * (length - len(str_num))
+        combinations.append("".join((zeros, str_num)))
+    return combinations
+
+
+def get_crypto_hash(password: str) -> str:
+    return hashlib.sha256(password.encode()).hexdigest()
+
+
+def check_password(expected_crypto_hash: str,
+                   possible_password: str) -> bool:
+    actual_crypto_hash = get_crypto_hash(possible_password)
+    return expected_crypto_hash == actual_crypto_hash
+
+
+def get_chunks(num_ranges: int, length: int) -> T.Iterator[ChunkRange]:
+    """パスワード範囲をチャンクに分割"""
+    max_number = int(math.pow(10, length) - 1)
+    chunk_starts = [int(max_number / num_ranges * i)
+                    for i in range(num_ranges)]
+    chunk_ends = [start - 1 for start in chunk_starts[1:]] + [max_number]
+    return zip(chunk_starts, chunk_ends)
+
+
+def crack_chunk(crypto_hash: str, length: int,
+                chunk_start: int, chunk_end: int) -> T.Union[str, None]:
+    """チャンク内でパスワードを探索"""
+    print(f"Processing {chunk_start} to {chunk_end}")
+    combinations = get_combinations(
+        length=length, min_number=chunk_start, max_number=chunk_end)
+    for combination in combinations:
+        if check_password(crypto_hash, combination):
+            return combination
+    return None
+
+
+def crack_password_parallel(crypto_hash: str, length: int) -> None:
+    """複数プロセスでパスワードを解読"""
+    num_cores = os.cpu_count()
+    print("Processing number combinations concurrently")
+    start_time = time.perf_counter()
+
+    with Pool() as pool:
+        arguments = ((crypto_hash, length, start, end)
+                     for start, end in get_chunks(num_cores, length))
+        results = pool.starmap(crack_chunk, arguments)
+        pool.close()
+        pool.join()
+
+    result = [res for res in results if res]
+    print(f"PASSWORD CRACKED: {result[0]}")
+    process_time = time.perf_counter() - start_time
+    print(f"PROCESS TIME: {process_time}")
+
+
+if __name__ == "__main__":
+    crypto_hash = \
+        "e24df920078c3dd4e7e8d2442f00e5c9ab2a231bb3918d65cc50906e49ecaef4"
+    length = 8
+    crack_password_parallel(crypto_hash, length)
+```
+
+### パフォーマンス比較
+
+| 処理方式 | 処理時間 | CPU 使用率 |
+|----------|----------|------------|
+| 逐次処理 | ~60秒 | 25% (1コア) |
+| 並列処理（4コア） | ~15秒 | 100% (全コア) |
+
+---
+
+## GIL (Global Interpreter Lock)
+
+Python の CPython 実装には GIL があり、一度に1つのスレッドしか Python バイトコードを実行できません。
+
+### GIL の影響
+
+| タスクタイプ | スレッド | プロセス |
+|--------------|----------|----------|
+| I/O バウンド | 効果的 | 効果的 |
+| CPU バウンド | 効果なし | 効果的 |
+
+### 使い分けの指針
+
+- **I/O バウンド処理**（ファイル読み書き、ネットワーク通信）→ スレッド
+- **CPU バウンド処理**（計算処理）→ プロセス
+
+---
+
+## 次のステップ
+
+Part III では、マルチタスキングとスケジューリングの概念を学びます。OS がどのようにタスクを切り替えるか、タイムシェアリングの仕組みを理解します。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 4/multithreading.py](../../../apps/python/Chapter%204/multithreading.py)
+- [apps/python/Chapter 4/process_lifecycle.py](../../../apps/python/Chapter%204/process_lifecycle.py)
+- [apps/python/Chapter 5/thread_pool.py](../../../apps/python/Chapter%205/thread_pool.py)
+- [apps/python/Chapter 5/password_cracking_parallel.py](../../../apps/python/Chapter%205/password_cracking_parallel.py)

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

@@ -0,0 +1,227 @@
+---
+title: Part III - マルチタスキングとスケジューリング
+description: マルチタスキングとタイムシェアリングの概念を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, multitasking, scheduling, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、OS がどのように複数のタスクを同時に実行しているように見せるかを学びます。マルチタスキングとタイムシェアリングの仕組みを、ゲームループの実装を通じて理解します。
+
+---
+
+## 第6章: マルチタスキング
+
+### マルチタスキングとは
+
+マルチタスキングは、複数のタスクを切り替えながら実行することで、あたかも同時に実行しているように見せる技術です。
+
+### タイムシェアリング
+
+CPU 時間を小さなスライスに分割し、各タスクに順番に割り当てます。
+
+```plantuml
+@startuml
+!theme plain
+title タイムシェアリング
+
+concise "CPU" as cpu
+
+@0
+cpu is "T1"
+
+@1
+cpu is "T2"
+
+@2
+cpu is "T3"
+
+@3
+cpu is "T1"
+
+@4
+cpu is "T2"
+
+@5
+cpu is "T3"
+
+@1 <-> @2 : コンテキストスイッチ
+@enduml
+```
+
+---
+
+### ゲームループの実装
+
+アーケードゲーム（パックマン）を例に、マルチタスキングを実装します。
+
+#### ゲームの3つのタスク
+
+1. **入力処理** - ユーザーの操作を受け付ける
+2. **ゲーム計算** - ゲーム世界の状態を更新
+3. **描画処理** - 画面を更新
+
+#### シンプルな実装（イベントベース）
+
+```python
+#!/usr/bin/env python3
+
+"""イベントベースのゲームループ"""
+
+import typing as T
+from threading import Thread, Event
+
+from pacman import get_user_input, compute_game_world, render_next_screen
+
+# プロセッサが空いているかを示すイベント
+processor_free = Event()
+processor_free.set()
+
+
+class Task(Thread):
+    def __init__(self, func: T.Callable[..., None]):
+        super().__init__()
+        self.func = func
+
+    def run(self) -> None:
+        while True:
+            processor_free.wait()   # シグナルを待つ
+            processor_free.clear()  # 他のタスクをブロック
+            self.func()             # タスクを実行
+            processor_free.set()    # 次のタスクを許可
+
+
+def arcade_machine() -> None:
+    """アーケードマシンのメイン機能"""
+    get_user_input_task = Task(get_user_input)
+    compute_game_world_task = Task(compute_game_world)
+    render_next_screen_task = Task(render_next_screen)
+
+    get_user_input_task.start()
+    compute_game_world_task.start()
+    render_next_screen_task.start()
+
+
+if __name__ == "__main__":
+    arcade_machine()
+```
+
+### Event オブジェクトの役割
+
+`threading.Event` は、スレッド間の同期に使用されます。
+
+| メソッド | 説明 |
+|----------|------|
+| `set()` | フラグを True に設定 |
+| `clear()` | フラグを False に設定 |
+| `wait()` | フラグが True になるまでブロック |
+| `is_set()` | フラグの状態を確認 |
+
+### パックマンの実装
+
+```python
+"""パックマンゲームの実装"""
+
+import sys
+import time
+import select
+from random import randrange
+
+# グローバルなゲーム状態
+PACMAN_POSITION = {}
+
+
+def get_user_input() -> None:
+    """コントローラからの入力を取得"""
+    global PACMAN_POSITION
+    i, o, e = select.select([sys.stdin], [], [], 1)
+    if i:
+        user_input = sys.stdin.readline().strip()
+        print(f"user input: {user_input}")
+        PACMAN_POSITION["user_input"] = user_input
+
+
+def compute_game_world() -> None:
+    """ゲームルールに従って世界を計算"""
+    global PACMAN_POSITION
+    print(f"Pacman doing: {PACMAN_POSITION.get('user_input', 'N/A')}")
+    print("computing")
+    PACMAN_POSITION["position"] = randrange(10)
+    time.sleep(1)
+
+
+def render_next_screen() -> None:
+    """次のフレームを描画"""
+    global PACMAN_POSITION
+    print(f"Rendering pacman at position: "
+          f"{PACMAN_POSITION.get('position', 0)}")
+    print("rendering")
+    time.sleep(0.5)
+```
+
+---
+
+## コンテキストスイッチ
+
+タスクを切り替える際、現在のタスクの状態を保存し、次のタスクの状態を復元します。
+
+### コンテキストスイッチのコスト
+
+- レジスタの保存と復元
+- メモリキャッシュの無効化
+- TLB（Translation Lookaside Buffer）のフラッシュ
+
+```plantuml
+@startuml
+!theme plain
+title タスク切り替えのオーバーヘッド
+
+rectangle "コンテキストスイッチ" {
+  card "状態保存" as save #LightBlue
+  card "スケジューラ実行" as sched #LightYellow
+  card "状態復元" as restore #LightGreen
+}
+
+note bottom of save : ~数マイクロ秒
+note bottom of sched : ~数マイクロ秒
+note bottom of restore : ~数マイクロ秒
+
+save --> sched
+sched --> restore
+@enduml
+```
+
+---
+
+## プリエンプティブ vs 協調的
+
+### プリエンプティブ・マルチタスキング
+
+- OS がタスクを強制的に中断
+- タイムスライスで制御
+- 公平なリソース配分
+
+### 協調的マルチタスキング
+
+- タスクが自発的に制御を譲る
+- `yield` で制御を返す
+- 効率的だが、行儀の悪いタスクに注意
+
+---
+
+## 次のステップ
+
+Part IV では、タスク分解と並列パターン（Fork/Join、パイプライン）を学びます。複雑な問題を並列化可能なサブタスクに分割する手法を理解します。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 6/arcade_machine.py](../../../apps/python/Chapter%206/arcade_machine.py)
+- [apps/python/Chapter 6/pacman.py](../../../apps/python/Chapter%206/pacman.py)