@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,213 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: 並列処理のデザインパターンを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, fork-join, pipeline, java
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、複雑な問題を並列化可能なサブタスクに分割する手法を学びます。Fork/Join パターンとパイプラインパターンの実装を通じて、並列処理のデザインパターンを理解します。
+
+---
+
+## 第7章: 並列パターン
+
+### データ並列 vs タスク並列
+
+| パターン | 説明 | 例 |
+|----------|------|-----|
+| データ並列 | 同じ操作を複数のデータに適用 | 配列の各要素を2倍 |
+| タスク並列 | 異なる操作を同時に実行 | 入力・計算・出力 |
+
+---
+
+## Fork/Join パターン
+
+問題を分割し、並列に処理した後、結果を統合するパターンです。
+
+### 投票集計の例
+
+**ソースファイル**: `apps/java/src/main/java/concurrency/ch07/VoteCounter.java`
+
+```java
+public class VoteCounter {
+
+    public static Map<Integer, Integer> countVotes(List<Integer> votes) {
+        Map<Integer, Integer> result = new HashMap<>();
+        for (Integer vote : votes) {
+            result.merge(vote, 1, Integer::sum);
+        }
+        return result;
+    }
+
+    public static Map<Integer, Integer> countVotesParallel(List<Integer> votes, int numWorkers) {
+        int chunkSize = (int) Math.ceil((double) votes.size() / numWorkers);
+        List<List<Integer>> chunks = new ArrayList<>();
+
+        for (int i = 0; i < votes.size(); i += chunkSize) {
+            chunks.add(votes.subList(i, Math.min(i + chunkSize, votes.size())));
+        }
+
+        try (ExecutorService executor = Executors.newFixedThreadPool(numWorkers)) {
+            // Fork: 各ワーカーにチャンクを割り当て
+            List<Future<Map<Integer, Integer>>> futures = new ArrayList<>();
+            for (List<Integer> chunk : chunks) {
+                futures.add(executor.submit(() -> countVotes(chunk)));
+            }
+
+            // Join: 結果を統合
+            Map<Integer, Integer> total = new HashMap<>();
+            for (Future<Map<Integer, Integer>> future : futures) {
+                total = mergeResults(total, future.get());
+            }
+            return total;
+        }
+    }
+
+    public static Map<Integer, Integer> mergeResults(Map<Integer, Integer> result1,
+                                                      Map<Integer, Integer> result2) {
+        Map<Integer, Integer> merged = new HashMap<>(result1);
+        result2.forEach((key, value) -> merged.merge(key, value, Integer::sum));
+        return merged;
+    }
+}
+```
+
+### 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
+```
+
+---
+
+## パイプラインパターン
+
+処理をステージに分割し、各ステージを並列に実行するパターンです。
+
+### 洗濯パイプラインの例
+
+**ソースファイル**: `apps/java/src/main/java/concurrency/ch07/Pipeline.java`
+
+```java
+public class Pipeline<T> {
+
+    public record Stage<I, O>(String name, Function<I, O> processor) {}
+
+    private final List<StageWorker> workers = new ArrayList<>();
+    private final List<BlockingQueue<Object>> queues = new ArrayList<>();
+
+    public <I, O> void addStage(String name, Function<I, O> processor) {
+        // ステージ間のキューを設定
+        BlockingQueue<Object> inputQueue = queues.isEmpty() ?
+            new LinkedBlockingQueue<>() : queues.get(queues.size() - 1);
+        BlockingQueue<Object> outputQueue = new LinkedBlockingQueue<>();
+        queues.add(outputQueue);
+
+        workers.add(new StageWorker(name, inputQueue, outputQueue, processor));
+    }
+
+    public void start() {
+        for (StageWorker worker : workers) {
+            worker.start();
+        }
+    }
+
+    public void submit(T item) {
+        queues.get(0).offer(item);
+    }
+}
+```
+
+### パイプラインの流れ
+
+```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"
+@enduml
+```
+
+---
+
+## BlockingQueue によるスレッド間通信
+
+`java.util.concurrent.BlockingQueue` はスレッドセーフなキューです。
+
+| メソッド | 説明 |
+|----------|------|
+| `put(item)` | アイテムを追加（ブロッキング） |
+| `take()` | アイテムを取得（ブロッキング） |
+| `offer(item)` | アイテムを追加（ノンブロッキング） |
+| `poll()` | アイテムを取得（ノンブロッキング） |
+
+---
+
+## 実行方法
+
+```bash
+cd apps/java
+./gradlew test --tests "concurrency.ch07.*"
+```
+
+---
+
+## 次のステップ
+
+Part V では、同期と排他制御を学びます。レースコンディション、デッドロックなどの問題と、Lock、Semaphore による解決策を理解します。
+
+---
+
+## 参考コード
+
+- [apps/java/src/main/java/concurrency/ch07/VoteCounter.java](../../../apps/java/src/main/java/concurrency/ch07/VoteCounter.java)
+- [apps/java/src/main/java/concurrency/ch07/Pipeline.java](../../../apps/java/src/main/java/concurrency/ch07/Pipeline.java)

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

@@ -0,0 +1,112 @@
+---
+title: Part V - 同期と排他制御
+description: レースコンディション、デッドロックと Lock、Semaphore を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, lock, semaphore, deadlock, java
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、並行処理における同期と排他制御を学びます。レースコンディション、デッドロックなどの問題と、Lock、Semaphore による解決策を理解します。
+
+---
+
+## 第8章: Lock と排他制御
+
+### レースコンディション
+
+複数のスレッドが共有リソースに同時アクセスすると、予期しない結果が発生することがあります。
+
+### 銀行口座の例
+
+**ソースファイル**: `apps/java/src/main/java/concurrency/ch08/BankAccount.java`
+
+```java
+public class BankAccount {
+    private final Lock lock = new ReentrantLock();
+    private int balance;
+
+    public void deposit(int amount) {
+        lock.lock();
+        try {
+            balance += amount;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public boolean withdraw(int amount) {
+        lock.lock();
+        try {
+            if (balance >= amount) {
+                balance -= amount;
+                return true;
+            }
+            return false;
+        } finally {
+            lock.unlock();
+        }
+    }
+}
+```
+
+### デッドロック回避
+
+複数のロックを取得する場合、常に同じ順序でロックを取得することでデッドロックを回避できます。
+
+```java
+public static boolean transfer(BankAccount from, BankAccount to, int amount) {
+    // 常に同じ順序でロックを取得
+    BankAccount first = System.identityHashCode(from) < System.identityHashCode(to) ? from : to;
+    BankAccount second = first == from ? to : from;
+
+    first.lock.lock();
+    try {
+        second.lock.lock();
+        try {
+            if (from.balance >= amount) {
+                from.balance -= amount;
+                to.balance += amount;
+                return true;
+            }
+            return false;
+        } finally {
+            second.lock.unlock();
+        }
+    } finally {
+        first.lock.unlock();
+    }
+}
+```
+
+---
+
+## 同期プリミティブ
+
+| API | 説明 |
+|-----|------|
+| `ReentrantLock` | 再入可能なロック |
+| `ReadWriteLock` | 読み取り/書き込みロック |
+| `Semaphore` | カウンティングセマフォ |
+| `CountDownLatch` | カウントダウンラッチ |
+| `CyclicBarrier` | サイクリックバリア |
+
+---
+
+## 実行方法
+
+```bash
+cd apps/java
+./gradlew test --tests "concurrency.ch08.*"
+```
+
+---
+
+## 参考コード
+
+- [apps/java/src/main/java/concurrency/ch08/BankAccount.java](../../../apps/java/src/main/java/concurrency/ch08/BankAccount.java)

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

@@ -0,0 +1,69 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: ノンブロッキング I/O とイベント駆動プログラミングを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, non-blocking, event-loop, nio, java
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、スレッドを使わずに並行処理を実現するノンブロッキング I/O とイベント駆動プログラミングを学びます。Java NIO を使った実装を通じて理解を深めます。
+
+---
+
+## Java NIO の主要クラス
+
+| クラス | 説明 |
+|--------|------|
+| `Selector` | I/O 多重化セレクタ |
+| `Channel` | I/O チャネル |
+| `ByteBuffer` | バイトバッファ |
+| `SelectionKey` | セレクションキー |
+
+### ノンブロッキング I/O の例
+
+```java
+// ノンブロッキングモードに設定
+channel.configureBlocking(false);
+
+// セレクタに登録
+selector.register(channel, SelectionKey.OP_READ);
+
+// イベントループ
+while (true) {
+    selector.select();
+    for (SelectionKey key : selector.selectedKeys()) {
+        if (key.isReadable()) {
+            // 読み取り処理
+        }
+    }
+}
+```
+
+---
+
+## シングルスレッドの利点
+
+| 利点 | 説明 |
+|------|------|
+| ロック不要 | 共有状態の競合なし |
+| 軽量 | スレッドのオーバーヘッドなし |
+| スケーラブル | 大量接続を効率的に処理 |
+| 予測可能 | 実行順序が明確 |
+
+---
+
+## 次のステップ
+
+Part VII では、Java の CompletableFuture と Virtual Threads を使った非同期プログラミングを学びます。
+
+---
+
+## 参考資料
+
+- [Java NIO Tutorial](https://docs.oracle.com/javase/tutorial/essential/io/fileio.html)

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

@@ -0,0 +1,101 @@
+---
+title: Part VII - 非同期プログラミング
+description: CompletableFuture と Virtual Threads を使った非同期プログラミングを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, async, completablefuture, virtual-threads, java
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、Java の CompletableFuture と Virtual Threads（Java 21）を使った非同期プログラミングを学びます。
+
+---
+
+## CompletableFuture
+
+### 基本的な使い方
+
+```java
+CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
+    // 非同期処理
+    return "Result";
+});
+
+// 結果を取得
+String result = future.get();
+```
+
+### チェーン処理
+
+```java
+CompletableFuture.supplyAsync(() -> fetchData())
+    .thenApply(data -> process(data))
+    .thenAccept(result -> save(result));
+```
+
+### 並行実行
+
+```java
+CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> fetchData1());
+CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> fetchData2());
+
+// すべての完了を待機
+CompletableFuture.allOf(future1, future2).join();
+```
+
+---
+
+## Virtual Threads (Java 21+)
+
+### 基本的な使い方
+
+```java
+// Virtual Thread で実行
+Thread.startVirtualThread(() -> {
+    System.out.println("Running in virtual thread");
+});
+
+// Virtual Thread の ExecutorService
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+    executor.submit(() -> {
+        System.out.println("Task in virtual thread");
+    });
+}
+```
+
+### プラットフォームスレッドとの違い
+
+| 特性 | プラットフォームスレッド | Virtual Thread |
+|------|------------------------|----------------|
+| 作成コスト | 高い | 低い |
+| メモリ | ~1MB/スレッド | ~KB/スレッド |
+| 最大数 | 数千 | 数百万 |
+| ブロッキング | 非効率 | 効率的 |
+
+---
+
+## 使い分けの指針
+
+| シナリオ | 推奨 |
+|----------|------|
+| I/O バウンド | Virtual Thread / CompletableFuture |
+| CPU バウンド | プラットフォームスレッド |
+| 混合 | Virtual Thread + 並列ストリーム |
+
+---
+
+## 次のステップ
+
+Part VIII では、MapReduce パターンと分散並列処理を学びます。
+
+---
+
+## 参考資料
+
+- [Java CompletableFuture](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/CompletableFuture.html)
+- [Virtual Threads (JEP 444)](https://openjdk.org/jeps/444)

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

@@ -0,0 +1,101 @@
+---
+title: Part VIII - 分散並列処理
+description: MapReduce パターンと分散処理を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, mapreduce, distributed, java
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、MapReduce パターンを使った分散並列処理を学びます。行列乗算とワードカウントの実装を通じて、大規模データの並列処理手法を理解します。
+
+---
+
+## MapReduce パターン
+
+### 処理フロー
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Input Data" as input
+rectangle "Map" as map #LightBlue
+rectangle "Shuffle" as shuffle #LightYellow
+rectangle "Reduce" as reduce #LightGreen
+rectangle "Output Data" as output
+
+input --> map
+map --> shuffle
+shuffle --> reduce
+reduce --> output
+
+note right of map : 各データに関数を適用
+note right of shuffle : キーでグループ化
+note right of reduce : グループごとに集約
+@enduml
+```
+
+### ワードカウントの例
+
+```java
+public class WordCount {
+
+    // Map: テキストを (word, 1) のペアに変換
+    public static List<Map.Entry<String, Integer>> map(String text) {
+        return Arrays.stream(text.toLowerCase().split("\\s+"))
+            .map(word -> Map.entry(word, 1))
+            .toList();
+    }
+
+    // Reduce: 同じ単語のカウントを集約
+    public static Map<String, Integer> reduce(List<Map.Entry<String, Integer>> pairs) {
+        return pairs.stream()
+            .collect(Collectors.groupingBy(
+                Map.Entry::getKey,
+                Collectors.summingInt(Map.Entry::getValue)
+            ));
+    }
+
+    // MapReduce
+    public static Map<String, Integer> wordCount(List<String> texts) {
+        // Map フェーズ（並列）
+        List<Map.Entry<String, Integer>> mapped = texts.parallelStream()
+            .flatMap(text -> map(text).stream())
+            .toList();
+
+        // Reduce フェーズ
+        return reduce(mapped);
+    }
+}
+```
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | 基本概念、パフォーマンス測定 |
+| II | スレッド/プロセス | ExecutorService、スレッドプール |
+| III | マルチタスキング | タイムシェアリング |
+| IV | 並列パターン | Fork/Join、パイプライン |
+| V | 同期 | Lock、デッドロック |
+| VI | ノンブロッキング I/O | NIO、Selector |
+| VII | 非同期 | CompletableFuture、Virtual Threads |
+| VIII | 分散処理 | MapReduce |
+
+---
+
+## 参考資料
+
+- [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/)