@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,93 @@
+---
+title: Part III - マルチタスキングとスケジューリング
+description: ゲームループで学ぶマルチタスキング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, multitasking, gameloop, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、ゲームループを例にマルチタスキングとスケジューリングを学びます。
+
+---
+
+## ゲームタスク
+
+```scala
+case class GameTask(name: String, action: () => Unit):
+  def run(): Unit = action()
+```
+
+---
+
+## イベント同期
+
+```scala
+class ProcessorFreeEvent:
+  private val lock = new Object
+  @volatile private var signaled = false
+
+  def waitForSignal(): Unit = lock.synchronized {
+    while !signaled do lock.wait()
+  }
+
+  def signal(): Unit = lock.synchronized {
+    signaled = true
+    lock.notifyAll()
+  }
+
+  def reset(): Unit = lock.synchronized {
+    signaled = false
+  }
+```
+
+---
+
+## ゲームループ
+
+```scala
+object GameLoop:
+  /** Run all tasks in a single frame */
+  def runOneFrame(tasks: List[GameTask]): Unit =
+    tasks.foreach(_.run())
+
+  /** Run game loop for specified number of frames */
+  def run(tasks: List[GameTask], frames: Int): Unit =
+    (1 to frames).foreach { frame =>
+      println(s"Frame $frame")
+      runOneFrame(tasks)
+    }
+```
+
+---
+
+## 使用例
+
+```scala
+val tasks = List(
+  GameTask("Input", () => println("Processing input...")),
+  GameTask("Update", () => println("Updating game state...")),
+  GameTask("Render", () => println("Rendering frame..."))
+)
+
+GameLoop.run(tasks, 3)
+```
+
+---
+
+## ポイント
+
+- **case class**: イミュータブルなデータ構造
+- **synchronized**: JVM レベルのロック
+- **@volatile**: メモリ可視性の保証
+
+---
+
+## 次のステップ
+
+[Part IV](part-4.md) では、Fork/Join パターンとパイプラインを学びます。

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

@@ -0,0 +1,110 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: Fork/Join パターンとパイプラインパターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, fork-join, pipeline, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、Fork/Join パターンとパイプラインパターンを学びます。
+
+---
+
+## Fork/Join パターン: 投票カウンター
+
+### 逐次カウント
+
+```scala
+object VoteCounter:
+  /** Count votes sequentially */
+  def countVotes(votes: List[String]): Map[String, Int] =
+    votes.groupBy(identity).view.mapValues(_.size).toMap
+
+  /** Merge two vote count results */
+  def mergeResults(a: Map[String, Int], b: Map[String, Int]): Map[String, Int] =
+    (a.keys ++ b.keys).map { key =>
+      key -> (a.getOrElse(key, 0) + b.getOrElse(key, 0))
+    }.toMap
+```
+
+### 並列カウント
+
+```scala
+import scala.concurrent.{Future, Await, ExecutionContext}
+import scala.concurrent.duration.Duration
+
+given ExecutionContext = ExecutionContext.global
+
+/** Count votes using fork-join pattern */
+def countVotesParallel(votes: List[String]): Map[String, Int] =
+  if votes.isEmpty then return Map.empty
+
+  val numCores = Runtime.getRuntime.availableProcessors()
+  val chunkSize = math.max(1, votes.size / numCores)
+  val chunks = votes.grouped(chunkSize).toList
+
+  val futures = chunks.map { chunk =>
+    Future(countVotes(chunk))
+  }
+
+  val results = futures.map(f => Await.result(f, Duration.Inf))
+  results.reduce(mergeResults)
+```
+
+---
+
+## パイプラインパターン
+
+```scala
+case class Stage(name: String, processor: Any => Any)
+
+class Pipeline[T](stages: List[Stage] = List.empty):
+
+  /** Add a stage to the pipeline */
+  def addStage[A, B](name: String, processor: A => B): Pipeline[T] =
+    new Pipeline[T](stages :+ Stage(name, x => processor(x.asInstanceOf[A])))
+
+  /** Process data through all stages */
+  def process(data: List[T]): List[Any] =
+    if stages.isEmpty then return data
+
+    data.map { item =>
+      stages.foldLeft[Any](item) { (current, stage) =>
+        stage.processor(current)
+      }
+    }
+
+object Pipeline:
+  def apply[T](): Pipeline[T] = new Pipeline[T]()
+```
+
+### 使用例
+
+```scala
+val pipeline = Pipeline[Int]()
+  .addStage("double", (x: Int) => x * 2)
+  .addStage("addOne", (x: Int) => x + 1)
+
+val results = pipeline.process(List(1, 2, 3))
+// List(3, 5, 7)
+```
+
+---
+
+## ポイント
+
+- **groupBy + mapValues**: 関数型スタイルの集計
+- **foldLeft**: ステージを順次適用
+- **ビルダーパターン**: 流暢なインターフェース
+
+---
+
+## 次のステップ
+
+[Part V](part-5.md) では、同期と排他制御を学びます。

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

@@ -0,0 +1,119 @@
+---
+title: Part V - 同期と排他制御
+description: 銀行口座で学ぶロックとデッドロック回避
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, synchronization, lock, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、銀行口座を例に同期とデッドロック回避を学びます。
+
+---
+
+## 銀行口座クラス
+
+```scala
+class BankAccount(initialBalance: Int):
+  private val lock = new Object
+  private var balance: Int = initialBalance
+
+  def getBalance: Int = lock.synchronized {
+    balance
+  }
+
+  def deposit(amount: Int): Unit = lock.synchronized {
+    balance += amount
+  }
+
+  def withdraw(amount: Int): Boolean = lock.synchronized {
+    if balance >= amount then
+      balance -= amount
+      true
+    else
+      false
+  }
+```
+
+---
+
+## デッドロック回避
+
+```scala
+object BankAccount:
+  /** Transfer money between accounts atomically, avoiding deadlock */
+  def transfer(from: BankAccount, to: BankAccount, amount: Int): Boolean =
+    // Always lock in consistent order to avoid deadlock
+    val (first, second) = if System.identityHashCode(from) < System.identityHashCode(to)
+      then (from, to)
+      else (to, from)
+
+    first.lock.synchronized {
+      second.lock.synchronized {
+        if from.balance >= amount then
+          from.balance -= amount
+          to.balance += amount
+          true
+        else
+          false
+      }
+    }
+```
+
+---
+
+## デッドロックとは
+
+2 つのスレッドが互いのロックを待つ状態:
+
+```
+Thread A: lock(account1) -> waiting for lock(account2)
+Thread B: lock(account2) -> waiting for lock(account1)
+```
+
+### 解決策: ロック順序の統一
+
+`System.identityHashCode` を使用してロック順序を決定することで、すべてのスレッドが同じ順序でロックを取得します。
+
+---
+
+## 並行テスト
+
+```scala
+test("BankAccount should handle concurrent transfers safely"):
+  val account1 = new BankAccount(1000)
+  val account2 = new BankAccount(1000)
+
+  val executor = Executors.newFixedThreadPool(10)
+  val latch = new CountDownLatch(100)
+
+  (1 to 50).foreach { _ =>
+    executor.submit(new Runnable:
+      def run(): Unit =
+        BankAccount.transfer(account1, account2, 10)
+        latch.countDown()
+    )
+    executor.submit(new Runnable:
+      def run(): Unit =
+        BankAccount.transfer(account2, account1, 10)
+        latch.countDown()
+    )
+  }
+
+  latch.await()
+  executor.shutdown()
+
+  // Total balance should be preserved
+  (account1.getBalance + account2.getBalance) shouldBe 2000
+```
+
+---
+
+## 次のステップ
+
+[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。

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

@@ -0,0 +1,83 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: NIO と Selector パターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, nio, nonblocking, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、Java NIO を使用したノンブロッキング I/O を学びます。
+
+---
+
+## ブロッキング vs ノンブロッキング
+
+### ブロッキング I/O
+
+```scala
+// スレッドは I/O 完了まで待機
+val socket = new Socket("localhost", 8080)
+val input = socket.getInputStream
+val data = input.read() // ブロック
+```
+
+### ノンブロッキング I/O
+
+```scala
+import java.nio.channels._
+import java.nio.ByteBuffer
+
+val channel = SocketChannel.open()
+channel.configureBlocking(false)
+channel.connect(new InetSocketAddress("localhost", 8080))
+
+// 接続が完了していなければすぐに戻る
+while !channel.finishConnect() do
+  // 他の作業ができる
+```
+
+---
+
+## Selector パターン
+
+```scala
+import java.nio.channels.{Selector, SelectionKey}
+
+val selector = Selector.open()
+channel.register(selector, SelectionKey.OP_READ)
+
+// イベントを待機
+while true do
+  selector.select() // ブロック（イベントがあるまで）
+
+  val keys = selector.selectedKeys().iterator()
+  while keys.hasNext do
+    val key = keys.next()
+    keys.remove()
+
+    if key.isReadable then
+      // 読み取り処理
+      handleRead(key)
+```
+
+---
+
+## メリット
+
+| 項目 | ブロッキング | ノンブロッキング |
+|------|-------------|------------------|
+| スレッド数 | 接続数に比例 | 少数で対応可能 |
+| メモリ | 多い | 少ない |
+| 複雑さ | 低い | 高い |
+
+---
+
+## 次のステップ
+
+[Part VII](part-7.md) では、Scala の Future を使った非同期プログラミングを学びます。

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

@@ -0,0 +1,131 @@
+---
+title: Part VII - 非同期プログラミング
+description: Future と Promise による非同期処理
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, async, future, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、Scala の Future と Promise を使った非同期プログラミングを学びます。
+
+---
+
+## Future の基本
+
+```scala
+import scala.concurrent.{Future, ExecutionContext}
+import scala.concurrent.ExecutionContext.Implicits.global
+
+val future: Future[Int] = Future {
+  Thread.sleep(1000)
+  42
+}
+
+// コールバック
+future.onComplete {
+  case Success(value) => println(s"Result: $value")
+  case Failure(e) => println(s"Error: ${e.getMessage}")
+}
+```
+
+---
+
+## Future の合成
+
+### map と flatMap
+
+```scala
+val f1: Future[Int] = Future(10)
+val f2: Future[Int] = Future(20)
+
+// map: 結果を変換
+val doubled: Future[Int] = f1.map(_ * 2)
+
+// flatMap: Future を連結
+val sum: Future[Int] = f1.flatMap(a => f2.map(b => a + b))
+```
+
+### for 内包表記
+
+```scala
+val result: Future[Int] = for
+  a <- Future(10)
+  b <- Future(20)
+  c <- Future(30)
+yield a + b + c
+```
+
+---
+
+## 並列実行
+
+```scala
+import scala.concurrent.{Future, Await}
+import scala.concurrent.duration._
+
+// 並列に実行される
+val futures = List(
+  Future { Thread.sleep(1000); "A" },
+  Future { Thread.sleep(1000); "B" },
+  Future { Thread.sleep(1000); "C" }
+)
+
+// 全てを待機
+val results: Future[List[String]] = Future.sequence(futures)
+val values = Await.result(results, 5.seconds)
+// List("A", "B", "C") - 約 1 秒で完了
+```
+
+---
+
+## Promise
+
+```scala
+import scala.concurrent.Promise
+
+val promise = Promise[Int]()
+val future = promise.future
+
+// 別のスレッドで完了
+Future {
+  Thread.sleep(1000)
+  promise.success(42)
+}
+
+future.onComplete {
+  case Success(v) => println(s"Got: $v")
+  case Failure(e) => println(s"Failed: $e")
+}
+```
+
+---
+
+## エラーハンドリング
+
+```scala
+val future = Future {
+  throw new RuntimeException("Error!")
+}
+
+// recover: 失敗時のフォールバック
+val recovered = future.recover {
+  case _: RuntimeException => 0
+}
+
+// recoverWith: 失敗時に別の Future
+val recoveredWith = future.recoverWith {
+  case _: RuntimeException => Future.successful(0)
+}
+```
+
+---
+
+## 次のステップ
+
+[Part VIII](part-8.md) では、MapReduce パターンと並列コレクションを学びます。

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

@@ -0,0 +1,129 @@
+---
+title: Part VIII - 分散並列処理
+description: MapReduce パターンと並列コレクション
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, mapreduce, parallel-collections, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、MapReduce パターンと Scala の並列コレクションを学びます。
+
+---
+
+## MapReduce パターン
+
+### ワードカウント実装
+
+```scala
+import scala.collection.parallel.CollectionConverters.*
+
+object WordCount:
+
+  /** Map: Convert text to (word, 1) pairs */
+  def map(text: String): List[(String, Int)] =
+    text.toLowerCase
+      .split("\\s+")
+      .filter(_.nonEmpty)
+      .map(word => (word, 1))
+      .toList
+
+  /** Reduce: Aggregate word counts */
+  def reduce(pairs: List[(String, Int)]): Map[String, Int] =
+    pairs.groupBy(_._1).view.mapValues(_.map(_._2).sum).toMap
+
+  /** MapReduce: Count words in multiple texts using parallel collections */
+  def countWords(texts: List[String]): Map[String, Int] =
+    // Map phase (parallel)
+    val mapped = texts.par.flatMap(map).toList
+
+    // Reduce phase
+    reduce(mapped)
+```
+
+---
+
+## 使用例
+
+```scala
+val texts = List(
+  "hello world",
+  "hello scala",
+  "world of scala"
+)
+
+val result = WordCount.countWords(texts)
+// Map(hello -> 2, world -> 2, scala -> 2, of -> 1)
+```
+
+---
+
+## 並列コレクション
+
+### 基本的な使い方
+
+```scala
+import scala.collection.parallel.CollectionConverters.*
+
+val numbers = (1 to 1000000).toList
+
+// 逐次処理
+val seqSum = numbers.map(_ * 2).sum
+
+// 並列処理
+val parSum = numbers.par.map(_ * 2).sum
+```
+
+### 注意点
+
+```scala
+// 順序が保証されない
+val result = (1 to 10).par.map(x => s"$x: ${Thread.currentThread.getName}")
+// 順序はランダム
+
+// 副作用のある操作は危険
+var counter = 0
+(1 to 1000).par.foreach(_ => counter += 1) // 競合状態
+// counter < 1000 になる可能性あり
+```
+
+---
+
+## 並列コレクションの選択
+
+| コレクション | 並列版 | 適した操作 |
+|-------------|--------|-----------|
+| List | ParVector | map, filter |
+| Array | ParArray | インデックスアクセス |
+| Range | ParRange | 連続処理 |
+| Map | ParMap | キー操作 |
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | 基本概念、ブルートフォース |
+| II | スレッド | Thread、Future |
+| III | マルチタスキング | ゲームループ |
+| IV | 並列パターン | Fork/Join、Pipeline |
+| V | 同期 | synchronized、デッドロック回避 |
+| VI | ノンブロッキング | NIO、Selector |
+| VII | 非同期 | Future、Promise |
+| VIII | 分散処理 | MapReduce、並列コレクション |
+
+---
+
+## 参考資料
+
+- [Scala Parallel Collections](https://docs.scala-lang.org/overviews/parallel-collections/overview.html)
+- [Scala Futures and Promises](https://docs.scala-lang.org/overviews/core/futures.html)
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)