@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,313 @@
+---
+title: index
+description:
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags:
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Grokking Concurrency - Python 版
+
+本シリーズは「Grokking Concurrency」（Kirill Bobrov 著）の学習コンパニオンとして、並行処理プログラミングの概念を Python で実装しながら日本語で解説します。
+
+---
+
+## 対象読者
+
+- Python の経験があり、並行処理に興味がある開発者
+- マルチスレッド、マルチプロセスプログラミングを学びたい方
+- 非同期プログラミング（asyncio）を理解したいエンジニア
+- 並行処理の問題（デッドロック、レースコンディション）を理解したい方
+
+---
+
+## 記事一覧
+
+### [Part I: 並行処理の基礎](part-1.md)
+
+逐次処理と並行処理の違い、基本概念を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第2章 | 逐次処理、パスワードクラッキング例 |
+
+**キーワード**: 逐次処理、パフォーマンス測定、ブルートフォース
+
+---
+
+### [Part II: プロセスとスレッド](part-2.md)
+
+OS レベルの並行処理の基本単位を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第4章 | プロセス、スレッド、ライフサイクル |
+| 第5章 | スレッドプール、IPC、並列処理 |
+
+**キーワード**: Process、Thread、fork、スレッドプール、IPC
+
+---
+
+### [Part III: マルチタスキングとスケジューリング](part-3.md)
+
+マルチタスキングとタイムシェアリングの概念を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第6章 | マルチタスキング、タイムシェアリング、ゲームループ |
+
+**キーワード**: マルチタスキング、タイムシェアリング、スケジューリング
+
+---
+
+### [Part IV: タスク分解と並列パターン](part-4.md)
+
+並列処理のデザインパターンを学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第7章 | タスク分解、Fork/Join、パイプライン |
+
+**キーワード**: Fork/Join、パイプライン、データ並列、タスク並列
+
+---
+
+### [Part V: 同期と排他制御](part-5.md)
+
+並行処理における同期問題と解決策を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第8章 | レースコンディション、Lock、Semaphore |
+| 第9章 | デッドロック、ライブロック、スタベーション |
+
+**キーワード**: Lock、Semaphore、レースコンディション、デッドロック
+
+---
+
+### [Part VI: ノンブロッキング I/O](part-6.md)
+
+ノンブロッキング I/O とイベント駆動プログラミングを学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第10章 | ブロッキング vs ノンブロッキング I/O |
+| 第11章 | イベントループ、Reactor パターン |
+
+**キーワード**: ノンブロッキング I/O、イベントループ、Reactor
+
+---
+
+### [Part VII: 非同期プログラミング](part-7.md)
+
+Python の asyncio を使った非同期プログラミングを学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第12章 | Future、Coroutine、async/await |
+
+**キーワード**: asyncio、Future、Coroutine、async/await
+
+---
+
+### [Part VIII: 分散並列処理](part-8.md)
+
+MapReduce パターンと分散処理を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第13章 | MapReduce、行列乗算、ワードカウント |
+
+**キーワード**: MapReduce、分散処理、並列アルゴリズム
+
+---
+
+## 学習パス
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "学習の流れ" {
+  card "Part I\n基礎" as p1
+  card "Part II\nプロセス/スレッド" as p2
+  card "Part III\nマルチタスク" as p3
+  card "Part IV\n並列パターン" as p4
+  card "Part V\n同期" as p5
+  card "Part VI\nノンブロッキング" as p6
+  card "Part VII\n非同期" as p7
+  card "Part VIII\n分散処理" as p8
+}
+
+p1 --> p2
+p2 --> p3
+p3 --> p4
+p4 --> p5
+p5 --> p6
+p6 --> p7
+p7 --> p8
+
+@enduml
+```
+
+---
+
+## 使用ライブラリ
+
+| ライブラリ | 用途 | 対応章 |
+|------------|------|--------|
+| Python 3.9+ | 言語 | 全章 |
+| threading | スレッド操作 | Part II-V |
+| multiprocessing | プロセス操作 | Part II, IV, VIII |
+| asyncio | 非同期プログラミング | Part VII |
+| concurrent.futures | 高レベル並行処理 | Part II, IV |
+
+---
+
+## リポジトリ構成
+
+```
+grokking_concurrency/
+├── apps/python/                  # Python サンプルコード
+│   ├── Chapter 2/                # 逐次処理
+│   ├── Chapter 4/                # プロセスとスレッド
+│   ├── Chapter 5/                # スレッドプール、IPC
+│   ├── Chapter 6/                # マルチタスキング
+│   ├── Chapter 7/                # タスク分解
+│   ├── Chapter 8/                # 同期問題
+│   ├── Chapter 9/                # デッドロック
+│   ├── Chapter 10/               # ノンブロッキング I/O
+│   ├── Chapter 11/               # イベントループ
+│   ├── Chapter 12/               # 非同期プログラミング
+│   └── Chapter 13/               # MapReduce
+├── docs/journal/                 # 開発履歴
+└── docs/wiki/記事/...            # 解説記事（本ディレクトリ）
+    ├── index.md                  # この記事
+    ├── part-1.md                 # Part I
+    ├── part-2.md                 # Part II
+    └── ...                       # 以降の Part
+```
+
+---
+
+## Python と並行処理
+
+Python は並行処理の多くの概念をサポートしています:
+
+### プロセスとスレッド
+
+```python
+from threading import Thread
+from multiprocessing import Process
+
+def worker(name: str) -> None:
+    print(f"Hello from {name}")
+
+# スレッドを使用
+thread = Thread(target=worker, args=("Thread-1",))
+thread.start()
+thread.join()
+
+# プロセスを使用
+process = Process(target=worker, args=("Process-1",))
+process.start()
+process.join()
+```
+
+### スレッドプール
+
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+def task(n: int) -> int:
+    return n * 2
+
+with ThreadPoolExecutor(max_workers=4) as executor:
+    futures = [executor.submit(task, i) for i in range(10)]
+    results = [f.result() for f in futures]
+```
+
+### 同期プリミティブ
+
+```python
+from threading import Lock, Semaphore
+
+lock = Lock()
+semaphore = Semaphore(3)
+
+with lock:
+    # クリティカルセクション
+    pass
+
+with semaphore:
+    # 最大3つのスレッドが同時に実行可能
+    pass
+```
+
+### 非同期プログラミング
+
+```python
+import asyncio
+
+async def fetch_data(url: str) -> str:
+    await asyncio.sleep(1)  # I/O 待ち
+    return f"Data from {url}"
+
+async def main():
+    tasks = [fetch_data(f"url_{i}") for i in range(5)]
+    results = await asyncio.gather(*tasks)
+    print(results)
+
+asyncio.run(main())
+```
+
+---
+
+## 主要な概念
+
+本シリーズを通じて、以下の概念を学べます:
+
+### 並行処理 vs 並列処理
+
+| 概念 | 説明 |
+|------|------|
+| 並行処理 (Concurrency) | 複数のタスクを交互に実行し、進行させる |
+| 並列処理 (Parallelism) | 複数のタスクを物理的に同時に実行する |
+
+### GIL (Global Interpreter Lock)
+
+Python の CPython 実装には GIL があり、マルチスレッドでの CPU バウンド処理には制限があります:
+
+- **I/O バウンド処理**: スレッドで効果的
+- **CPU バウンド処理**: プロセスで効果的
+
+### 同期問題
+
+| 問題 | 説明 | 解決策 |
+|------|------|--------|
+| レースコンディション | 複数スレッドが共有リソースに競合 | Lock、Mutex |
+| デッドロック | 相互にリソースを待ち合い | 順序付け、タイムアウト |
+| ライブロック | 状態が変化するが進行しない | バックオフ戦略 |
+| スタベーション | 特定スレッドがリソースを取得できない | 公平なスケジューリング |
+
+---
+
+## 並行処理の利点
+
+1. **応答性向上** - UI がブロックされない
+2. **スループット向上** - 複数タスクを同時処理
+3. **リソース有効活用** - CPU、I/O の待ち時間を活用
+4. **スケーラビリティ** - マルチコアを活用
+
+---
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著
+- [Python 公式ドキュメント - threading](https://docs.python.org/3/library/threading.html)
+- [Python 公式ドキュメント - multiprocessing](https://docs.python.org/3/library/multiprocessing.html)
+- [Python 公式ドキュメント - asyncio](https://docs.python.org/3/library/asyncio.html)
+- [Real Python - Concurrency](https://realpython.com/python-concurrency/)

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

@@ -0,0 +1,239 @@
+---
+title: Part I - 並行処理の基礎
+description: 逐次処理と並行処理の違い、基本概念を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, sequential, python
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part I: 並行処理の基礎
+
+## 概要
+
+本章では、並行処理を学ぶ前提として逐次処理（Sequential Processing）の基本を理解します。パスワードクラッキングを例に、逐次処理の特徴と限界を確認します。
+
+---
+
+## 第2章: 逐次処理
+
+### 逐次処理とは
+
+逐次処理は、タスクを一つずつ順番に実行する最も基本的な処理方式です。
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "タスク1" as t1
+rectangle "タスク2" as t2
+rectangle "タスク3" as t3
+rectangle "完了" as done
+
+t1 --> t2
+t2 --> t3
+t3 --> done
+@enduml
+```
+
+### パスワードクラッキングの例
+
+ブルートフォース（総当たり）でパスワードを解読するプログラムを通じて、逐次処理の特徴を学びます。
+
+#### 実装の全体像
+
+```python
+#!/usr/bin/env python3
+
+"""パスワードクラッキング（逐次処理版）"""
+
+import time
+import math
+import hashlib
+import typing as T
+
+
+def get_combinations(*, length: int, min_number: int = 0,
+                     max_number: T.Optional[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 crack_password(crypto_hash: str, length: int) -> None:
+    """ブルートフォースでパスワードを解読"""
+    print("Processing number combinations sequentially")
+    start_time = time.perf_counter()
+
+    combinations = get_combinations(length=length)
+    for combination in combinations:
+        if check_password(crypto_hash, combination):
+            print(f"PASSWORD CRACKED: {combination}")
+            break
+
+    process_time = time.perf_counter() - start_time
+    print(f"PROCESS TIME: {process_time}")
+
+
+if __name__ == "__main__":
+    # "12345678" のSHA-256ハッシュ
+    crypto_hash = \
+        "e24df920078c3dd4e7e8d2442f00e5c9ab2a231bb3918d65cc50906e49ecaef4"
+    length = 8
+    crack_password(crypto_hash, length)
+```
+
+### コードの解説
+
+#### 1. パスワード組み合わせの生成
+
+```python
+def get_combinations(*, length: int, min_number: int = 0,
+                     max_number: T.Optional[int] = None) -> T.List[str]:
+    """全ての可能なパスワード組み合わせを生成"""
+    combinations = []
+    if not max_number:
+        # 8桁の場合: 10^8 - 1 = 99,999,999
+        max_number = int(math.pow(10, length) - 1)
+
+    for i in range(min_number, max_number + 1):
+        str_num = str(i)
+        # 先頭をゼロ埋め: 1 → "00000001"
+        zeros = "0" * (length - len(str_num))
+        combinations.append("".join((zeros, str_num)))
+    return combinations
+```
+
+8桁の数字パスワードの場合、`00000000` から `99999999` まで 1億通りの組み合わせを生成します。
+
+#### 2. ハッシュ関数
+
+```python
+def get_crypto_hash(password: str) -> str:
+    """パスワードの暗号ハッシュを計算"""
+    return hashlib.sha256(password.encode()).hexdigest()
+```
+
+SHA-256 を使用してパスワードをハッシュ化します。実際のシステムでは、パスワードは平文ではなくハッシュ値として保存されます。
+
+#### 3. パスワードチェック
+
+```python
+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
+```
+
+候補パスワードのハッシュと、保存されているハッシュを比較します。
+
+### パフォーマンス測定
+
+```python
+start_time = time.perf_counter()
+# ... 処理 ...
+process_time = time.perf_counter() - start_time
+print(f"PROCESS TIME: {process_time}")
+```
+
+`time.perf_counter()` は高精度のパフォーマンスカウンターで、経過時間の測定に適しています。
+
+---
+
+## 逐次処理の特徴
+
+### 利点
+
+| 利点 | 説明 |
+|------|------|
+| シンプル | 実装が簡単で理解しやすい |
+| 予測可能 | 実行順序が決定的 |
+| デバッグ容易 | 問題の特定が容易 |
+| 競合なし | 共有リソースの競合が発生しない |
+
+### 限界
+
+| 限界 | 説明 |
+|------|------|
+| 遅い | 1億通りを1つずつ処理するため時間がかかる |
+| リソース非効率 | マルチコア CPU を活用できない |
+| スケールしない | データ量に比例して処理時間が増加 |
+
+---
+
+## なぜ並行処理が必要か
+
+8桁のパスワードクラッキングでは、1億通りの組み合わせを順番にチェックします。
+
+```plantuml
+@startuml
+!theme plain
+title 逐次処理: CPU使用率 25%
+
+rectangle "CPU" {
+  rectangle "コア1" as c1 #LightGreen
+  rectangle "コア2" as c2 #LightGray
+  rectangle "コア3" as c3 #LightGray
+  rectangle "コア4" as c4 #LightGray
+}
+
+note right of c1 : 処理中...
+note right of c2 : アイドル
+note right of c3 : アイドル
+note right of c4 : アイドル
+@enduml
+```
+
+4コア CPU があっても、逐次処理では1コアしか使用されません。並行処理を使えば、複数コアに作業を分散できます。
+
+```plantuml
+@startuml
+!theme plain
+title 並行処理: CPU使用率 100%
+
+rectangle "CPU" {
+  rectangle "コア1" as c1 #LightGreen
+  rectangle "コア2" as c2 #LightGreen
+  rectangle "コア3" as c3 #LightGreen
+  rectangle "コア4" as c4 #LightGreen
+}
+
+note right of c1 : 00000000-24999999
+note right of c2 : 25000000-49999999
+note right of c3 : 50000000-74999999
+note right of c4 : 75000000-99999999
+@enduml
+```
+
+---
+
+## 次のステップ
+
+Part II では、プロセスとスレッドを使って並行処理を実装します。パスワードクラッキングを並列化し、処理時間を大幅に短縮する方法を学びます。
+
+---
+
+## 参考コード
+
+- [apps/python/Chapter 2/password_cracking_sequential.py](../../../apps/python/Chapter%202/password_cracking_sequential.py)