@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokking-concurrency/haskell/part-8.md

@@ -0,0 +1,118 @@
+---
+title: Part VIII - 分散並列処理
+description: MapReduce パターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, mapreduce, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、MapReduce パターンと mapConcurrently を学びます。
+
+---
+
+## MapReduce パターン
+
+### ワードカウント実装
+
+```haskell
+import Control.Concurrent.Async (mapConcurrently)
+import Data.Char (toLower)
+import Data.Map.Strict (Map)
+import qualified Data.Map.Strict as Map
+
+-- | Map: Convert text to (word, 1) pairs
+mapPhase :: String -> [(String, Int)]
+mapPhase text =
+    [(map toLower word, 1) | word <- words text, not (null word)]
+
+-- | Reduce: Aggregate word counts
+reducePhase :: [(String, Int)] -> Map String Int
+reducePhase = foldl' addPair Map.empty
+  where
+    addPair acc (word, count) = Map.insertWith (+) word count acc
+
+-- | MapReduce: Count words in multiple texts
+countWords :: [String] -> Map String Int
+countWords texts =
+    let mapped = concatMap mapPhase texts
+    in reducePhase mapped
+```
+
+---
+
+## 並列版
+
+```haskell
+-- | MapReduce with parallel execution
+countWordsParallel :: [String] -> IO (Map String Int)
+countWordsParallel [] = return Map.empty
+countWordsParallel texts = do
+    -- Map phase (parallel)
+    mapped <- mapConcurrently (return . mapPhase) texts
+    -- Reduce phase
+    return $ reducePhase (concat mapped)
+```
+
+---
+
+## 使用例
+
+```haskell
+main :: IO ()
+main = do
+    let texts = ["hello world", "hello haskell", "world of haskell"]
+
+    result <- countWordsParallel texts
+    -- fromList [("hello",2),("haskell",2),("of",1),("world",2)]
+    print result
+```
+
+---
+
+## mapConcurrently
+
+```haskell
+import Control.Concurrent.Async
+
+-- 並列 map
+results <- mapConcurrently processItem items
+
+-- 並列 filter + map
+results <- mapConcurrently (\x ->
+    if condition x
+        then return (Just (process x))
+        else return Nothing
+    ) items
+```
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | Maybe、純粋関数 |
+| II | スレッド | forkIO、async |
+| III | マルチタスキング | STM、TVar |
+| IV | 並列パターン | Fork/Join、Pipeline |
+| V | 同期 | STM、デッドロックフリー |
+| VI | ノンブロッキング | async |
+| VII | 非同期 | race、concurrently |
+| VIII | 分散処理 | MapReduce |
+
+---
+
+## 参考資料
+
+- [Parallel and Concurrent Programming in Haskell](https://simonmar.github.io/pages/pcph.html)
+- [async package](https://hackage.haskell.org/package/async)
+- [stm package](https://hackage.haskell.org/package/stm)
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)

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

@@ -0,0 +1,66 @@
+# Grokking Concurrency
+
+Python、Java、C#、Scala、F#、Rust、Haskell、Clojure で学ぶ並行処理プログラミング
+
+---
+
+## 概要
+
+本サイトは「Grokking Concurrency」（Kirill Bobrov 著）の学習コンパニオンとして、並行処理プログラミングの概念を複数の言語で実装しながら日本語で解説します。
+
+---
+
+## 多言語統合解説
+
+8 つの言語を横断的に比較し、並行処理の**本質**と**言語固有の表現**を統合的に解説します。
+
+| Part | トピック | 統合記事 |
+|------|----------|----------|
+| I | 並行処理の基礎 | [逐次処理の言語別比較](all/part-1-ch02-sequential.md) |
+| II | プロセスとスレッド | [スレッド生成・管理の API 比較](all/part-2-ch04-05-threads.md) |
+| III | マルチタスキング | [イベント駆動モデルの比較](all/part-3-ch06-multitasking.md) |
+| IV | 並列パターン | [Fork/Join・パイプラインの比較](all/part-4-ch07-parallel-patterns.md) |
+| V | 同期と排他制御 | [Lock/STM/所有権の比較](all/part-5-ch08-09-synchronization.md) |
+| VI | ノンブロッキング I/O | [Reactor パターンと I/O モデル比較](all/part-6-ch10-11-nonblocking-io.md) |
+| VII | 非同期プログラミング | [async/await と Future/Promise 比較](all/part-7-ch12-async.md) |
+| VIII | 分散並列処理 | [MapReduce と並列コレクション比較](all/part-8-ch13-mapreduce.md) |
+
+> 詳細は [多言語統合解説 概要](all/index.md) を参照
+
+---
+
+## 言語別学習ガイド
+
+| 言語 | 特徴 | 主要な並行処理機能 |
+|------|------|-------------------|
+| [Python](python/index.md) | 動的型付け、シンプル | threading, multiprocessing, asyncio |
+| [Java](java/index.md) | JVM、エンタープライズ | ExecutorService, CompletableFuture |
+| [C#](csharp/index.md) | .NET、モダン構文 | Task, async/await, TPL |
+| [Scala](scala/index.md) | 関数型+オブジェクト指向 | Future, Akka Actor |
+| [F#](fsharp/index.md) | .NET 関数型 | Async, MailboxProcessor |
+| [Rust](rust/index.md) | メモリ安全、ゼロコスト | std::thread, Rayon, tokio |
+| [Haskell](haskell/index.md) | 純粋関数型 | STM, async, forkIO |
+| [Clojure](clojure/index.md) | Lisp 系、JVM | atom, ref/STM, core.async |
+
+---
+
+## 学習トピック
+
+本シリーズでは以下のトピックを扱います：
+
+| Part | トピック | キーワード |
+|------|----------|------------|
+| I | 並行処理の基礎 | 逐次処理、パフォーマンス測定 |
+| II | プロセスとスレッド | Process、Thread、スレッドプール |
+| III | マルチタスキング | タイムシェアリング、スケジューリング |
+| IV | 並列パターン | Fork/Join、パイプライン |
+| V | 同期と排他制御 | Lock、Semaphore、デッドロック |
+| VI | ノンブロッキング I/O | イベントループ、Reactor |
+| VII | 非同期プログラミング | asyncio、async/await |
+| VIII | 分散並列処理 | MapReduce、分散処理 |
+
+---
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著（Manning Publications）

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

@@ -0,0 +1,102 @@
+---
+title: Java で学ぶ並行処理プログラミング
+description: Grokking Concurrency Java 版
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, java
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Java で学ぶ並行処理プログラミング
+
+## 概要
+
+このセクションでは、Grokking Concurrency の内容を **Java 21** で実装しながら学びます。TDD（テスト駆動開発）で実装されたコード例と、詳細なドキュメントを通じて、並行処理の基礎から応用までを理解できます。
+
+---
+
+## 目次
+
+### Part I: 並行処理の基礎
+
+逐次処理の特徴と限界を理解し、なぜ並行処理が必要かを学びます。
+
+- [Part I - 並行処理の基礎](part-1.md)
+
+### Part II: プロセスとスレッド
+
+OS レベルの並行処理の基本単位であるプロセスとスレッドを学びます。
+
+- [Part II - プロセスとスレッド](part-2.md)
+
+### Part III: マルチタスキング
+
+OS がどのようにタスクを切り替えるか、タイムシェアリングの仕組みを学びます。
+
+- [Part III - マルチタスキングとスケジューリング](part-3.md)
+
+### Part IV: タスク分解と並列パターン
+
+Fork/Join パターンとパイプラインパターンを学びます。
+
+- [Part IV - タスク分解と並列パターン](part-4.md)
+
+### Part V: 同期と排他制御
+
+Lock、Semaphore、デッドロックについて学びます。
+
+- [Part V - 同期と排他制御](part-5.md)
+
+### Part VI: ノンブロッキング I/O
+
+Java NIO を使ったノンブロッキング I/O を学びます。
+
+- [Part VI - ノンブロッキング I/O](part-6.md)
+
+### Part VII: 非同期プログラミング
+
+CompletableFuture と Virtual Threads を学びます。
+
+- [Part VII - 非同期プログラミング](part-7.md)
+
+### Part VIII: 分散並列処理
+
+MapReduce パターンと分散処理を学びます。
+
+- [Part VIII - 分散並列処理](part-8.md)
+
+---
+
+## 技術スタック
+
+- **Java 21** (Virtual Threads, Record, Pattern Matching)
+- **Gradle** (ビルドツール)
+- **JUnit 5** (テストフレームワーク)
+- **AssertJ** (アサーションライブラリ)
+
+---
+
+## 実行方法
+
+### テストの実行
+
+```bash
+cd apps/java
+./gradlew test
+```
+
+### サンプルコードの実行
+
+```bash
+cd apps/java
+./gradlew run -PmainClass=concurrency.ch02.PasswordCracker
+```
+
+---
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著
+- [Java Concurrency in Practice](https://jcip.net/) - Java 並行処理の名著
+- [Java 21 Documentation](https://docs.oracle.com/en/java/javase/21/)

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

@@ -0,0 +1,308 @@
+---
+title: Part I - 並行処理の基礎
+description: 逐次処理と並行処理の違い、基本概念を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, sequential, java
+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
+```
+
+### パスワードクラッキングの例
+
+ブルートフォース（総当たり）でパスワードを解読するプログラムを通じて、逐次処理の特徴を学びます。
+
+#### 実装の全体像
+
+**ソースファイル**: `apps/java/src/main/java/concurrency/ch02/PasswordCracker.java`
+
+```java
+package concurrency.ch02;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HexFormat;
+import java.util.List;
+
+/**
+ * パスワードクラッカー（逐次処理版）
+ * ブルートフォース（総当たり）でパスワードを解読する
+ */
+public class PasswordCracker {
+
+    public static List<String> getCombinations(int length, int minNumber, int maxNumber) {
+        List<String> combinations = new ArrayList<>();
+        String format = "%0" + length + "d";
+
+        for (int i = minNumber; i <= maxNumber; i++) {
+            combinations.add(String.format(format, i));
+        }
+        return combinations;
+    }
+
+    public static String getCryptoHash(String password) {
+        try {
+            MessageDigest digest = MessageDigest.getInstance("SHA-256");
+            byte[] hash = digest.digest(password.getBytes(StandardCharsets.UTF_8));
+            return HexFormat.of().formatHex(hash);
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException("SHA-256 algorithm not available", e);
+        }
+    }
+
+    public static boolean checkPassword(String expectedCryptoHash, String possiblePassword) {
+        String actualCryptoHash = getCryptoHash(possiblePassword);
+        return expectedCryptoHash.equals(actualCryptoHash);
+    }
+
+    public static String crackPassword(String cryptoHash, int length) {
+        int maxNumber = (int) Math.pow(10, length) - 1;
+        List<String> combinations = getCombinations(length, 0, maxNumber);
+
+        for (String combination : combinations) {
+            if (checkPassword(cryptoHash, combination)) {
+                return combination;
+            }
+        }
+        return null;
+    }
+
+    public static void main(String[] args) {
+        String cryptoHash = "ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f";
+        int length = 8;
+
+        System.out.println("Processing number combinations sequentially");
+        long startTime = System.nanoTime();
+
+        String result = crackPassword(cryptoHash, length);
+
+        long processTime = System.nanoTime() - startTime;
+        if (result != null) {
+            System.out.println("PASSWORD CRACKED: " + result);
+        }
+        System.out.printf("PROCESS TIME: %.3f seconds%n", processTime / 1_000_000_000.0);
+    }
+}
+```
+
+### コードの解説
+
+#### 1. パスワード組み合わせの生成
+
+```java
+public static List<String> getCombinations(int length, int minNumber, int maxNumber) {
+    List<String> combinations = new ArrayList<>();
+    String format = "%0" + length + "d";  // 先頭ゼロ埋めフォーマット
+
+    for (int i = minNumber; i <= maxNumber; i++) {
+        combinations.add(String.format(format, i));
+    }
+    return combinations;
+}
+```
+
+8桁の数字パスワードの場合、`00000000` から `99999999` まで 1億通りの組み合わせを生成します。
+
+#### 2. ハッシュ関数
+
+```java
+public static String getCryptoHash(String password) {
+    MessageDigest digest = MessageDigest.getInstance("SHA-256");
+    byte[] hash = digest.digest(password.getBytes(StandardCharsets.UTF_8));
+    return HexFormat.of().formatHex(hash);  // Java 17+ の HexFormat
+}
+```
+
+SHA-256 を使用してパスワードをハッシュ化します。`HexFormat` は Java 17 以降で利用可能な便利なクラスです。
+
+#### 3. パスワードチェック
+
+```java
+public static boolean checkPassword(String expectedCryptoHash, String possiblePassword) {
+    String actualCryptoHash = getCryptoHash(possiblePassword);
+    return expectedCryptoHash.equals(actualCryptoHash);
+}
+```
+
+候補パスワードのハッシュと、保存されているハッシュを比較します。
+
+### パフォーマンス測定
+
+```java
+long startTime = System.nanoTime();
+// ... 処理 ...
+long processTime = System.nanoTime() - startTime;
+System.out.printf("PROCESS TIME: %.3f seconds%n", processTime / 1_000_000_000.0);
+```
+
+`System.nanoTime()` は高精度のパフォーマンスカウンターで、経過時間の測定に適しています。
+
+---
+
+## TDD によるテスト
+
+**ソースファイル**: `apps/java/src/test/java/concurrency/ch02/PasswordCrackerTest.java`
+
+```java
+@Test
+@DisplayName("4桁の組み合わせを生成できる")
+void shouldGenerateFourDigitCombinations() {
+    List<String> combinations = PasswordCracker.getCombinations(4, 0, 9);
+
+    assertThat(combinations)
+        .hasSize(10)
+        .containsExactly(
+            "0000", "0001", "0002", "0003", "0004",
+            "0005", "0006", "0007", "0008", "0009"
+        );
+}
+
+@Test
+@DisplayName("SHA-256ハッシュを計算できる")
+void shouldCalculateSha256Hash() {
+    String hash = PasswordCracker.getCryptoHash("12345678");
+
+    assertThat(hash)
+        .isEqualTo("ef797c8118f02dfb649607dd5d3f8c7623048c9c063d532cc95c5ed7a898a64f");
+}
+
+@Test
+@DisplayName("パスワードをクラックできる")
+void shouldCrackPassword() {
+    String cryptoHash = PasswordCracker.getCryptoHash("1234");
+
+    String result = PasswordCracker.crackPassword(cryptoHash, 4);
+
+    assertThat(result).isEqualTo("1234");
+}
+```
+
+---
+
+## 逐次処理の特徴
+
+### 利点
+
+| 利点 | 説明 |
+|------|------|
+| シンプル | 実装が簡単で理解しやすい |
+| 予測可能 | 実行順序が決定的 |
+| デバッグ容易 | 問題の特定が容易 |
+| 競合なし | 共有リソースの競合が発生しない |
+
+### 限界
+
+| 限界 | 説明 |
+|------|------|
+| 遅い | 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
+```
+
+---
+
+## 実行方法
+
+### テストの実行
+
+```bash
+cd apps/java
+./gradlew test
+```
+
+### サンプルコードの実行
+
+```bash
+cd apps/java
+./gradlew run
+```
+
+---
+
+## 次のステップ
+
+Part II では、スレッドとプロセスを使って並行処理を実装します。パスワードクラッキングを並列化し、処理時間を大幅に短縮する方法を学びます。
+
+---
+
+## 参考コード
+
+- [apps/java/src/main/java/concurrency/ch02/PasswordCracker.java](../../../apps/java/src/main/java/concurrency/ch02/PasswordCracker.java)
+- [apps/java/src/test/java/concurrency/ch02/PasswordCrackerTest.java](../../../apps/java/src/test/java/concurrency/ch02/PasswordCrackerTest.java)