@k2works/claude-code-booster 6.2.0 → 6.3.1

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

@@ -1,303 +0,0 @@
-# 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

@@ -1,238 +0,0 @@
----
-type: Article
-title: "Part I - 並行処理の基礎"
-description: "逐次処理と並行処理の違い、基本概念を学ぶ"
-tags: [article, grokking-concurrency, python, concurrency, sequential]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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`