@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,122 @@
+---
+title: Part III - マルチタスキングとスケジューリング
+description: atom とイベント同期
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, atom
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、Clojure の atom とイベント同期を学びます。
+
+---
+
+## Atom（アトム）
+
+```clojure
+;; 作成
+(def counter (atom 0))
+
+;; 更新
+(swap! counter inc)        ;; 関数適用
+(swap! counter + 10)       ;; 引数付き
+(reset! counter 0)         ;; 直接設定
+
+;; 取得
+@counter  ;; または (deref counter)
+```
+
+---
+
+## イベント同期
+
+### イベントオブジェクト
+
+```clojure
+(defn create-event
+  "イベントオブジェクトを作成"
+  []
+  {:ready (atom false)
+   :lock (Object.)})
+
+(defn signal-event!
+  "イベントをシグナル"
+  [event]
+  (locking (:lock event)
+    (reset! (:ready event) true)
+    (.notifyAll (:lock event))))
+
+(defn wait-event!
+  "イベントを待機"
+  [event]
+  (locking (:lock event)
+    (while (not @(:ready event))
+      (.wait (:lock event)))
+    (reset! (:ready event) false)))
+```
+
+---
+
+## GameLoop 実装
+
+### ゲーム状態
+
+```clojure
+(defn create-game-state
+  "ゲーム状態を作成"
+  []
+  {:event-count (atom 0)
+   :rendered-count (atom 0)
+   :running (atom true)})
+
+(defn process-event! [state]
+  (swap! (:event-count state) inc))
+
+(defn render-frame! [state]
+  (swap! (:rendered-count state) inc))
+```
+
+---
+
+## ゲームループ
+
+```clojure
+(defn run-game-loop!
+  "ゲームループを実行"
+  [state iterations]
+  (let [processor-event (create-event)
+        renderer-event (create-event)]
+    ;; イベント処理スレッド
+    (future
+      (dotimes [_ iterations]
+        (wait-event! processor-event)
+        (process-event! state)
+        (signal-event! renderer-event)))
+    ;; レンダリングスレッド
+    (future
+      (dotimes [_ iterations]
+        (signal-event! processor-event)
+        (wait-event! renderer-event)
+        (render-frame! state)))))
+```
+
+---
+
+## atom vs ref
+
+| 特徴 | atom | ref |
+|------|------|-----|
+| 用途 | 単一値 | 複数値の協調更新 |
+| 更新 | swap!, reset! | alter, ref-set |
+| トランザクション | 不要 | dosync 必須 |
+
+---
+
+## 次のステップ
+
+[Part IV](part-4.md) では、Fork/Join と Pipeline パターンを学びます。

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

@@ -0,0 +1,123 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: Fork/Join と Pipeline
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, fork-join
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、Fork/Join パターンと Pipeline パターンを学びます。
+
+---
+
+## Fork/Join パターン
+
+### VoteCounter 実装
+
+```clojure
+(defn count-votes-sequential
+  "逐次で投票をカウント"
+  [votes]
+  (reduce (fn [acc vote]
+            (update acc vote (fnil inc 0)))
+          {}
+          votes))
+
+(defn merge-counts
+  "複数のカウント結果をマージ"
+  [counts]
+  (reduce (fn [acc m]
+            (merge-with + acc m))
+          {}
+          counts))
+```
+
+---
+
+## 並列 Fork/Join
+
+```clojure
+(defn count-votes-parallel
+  "並列で投票をカウント（Fork/Join パターン）"
+  [votes num-workers]
+  (if (empty? votes)
+    {}
+    (let [chunks (partition-all (max 1 (quot (count votes) num-workers)) votes)
+          futures (doall (map #(future (count-votes-sequential %)) chunks))
+          results (map deref futures)]
+      (merge-counts results))))
+```
+
+---
+
+## Pipeline パターン
+
+### core.async を使用
+
+```clojure
+(require '[clojure.core.async :as async :refer [chan go >! <! >!! <!!]])
+
+(defn create-pipeline
+  "入力を2倍にするパイプラインを作成"
+  []
+  (let [input (chan 10)
+        output (chan 10)]
+    (go
+      (loop []
+        (when-let [v (<! input)]
+          (>! output (* v 2))
+          (recur))))
+    {:input input :output output}))
+```
+
+---
+
+## パイプライン操作
+
+```clojure
+(defn send-to-pipeline! [pipeline value]
+  (>!! (:input pipeline) value))
+
+(defn receive-from-pipeline! [pipeline]
+  (<!! (:output pipeline)))
+
+;; 使用例
+(let [p (create-pipeline)]
+  (send-to-pipeline! p 5)
+  (receive-from-pipeline! p))  ;; => 10
+```
+
+---
+
+## チェーンパイプライン
+
+```clojure
+(defn run-chain-pipeline
+  "チェーンパイプラインを実行"
+  [initial-value functions]
+  (if (empty? functions)
+    initial-value
+    (let [channels (repeatedly (inc (count functions)) #(chan 1))]
+      (doseq [[in-ch out-ch f] (map vector channels (rest channels) functions)]
+        (go
+          (when-let [v (<! in-ch)]
+            (>! out-ch (f v)))))
+      (>!! (first channels) initial-value)
+      (<!! (last channels)))))
+
+;; 使用例
+(run-chain-pipeline 5 [#(* % 2) #(+ % 3) #(* % 10)])
+;; => 130  ; ((5 * 2) + 3) * 10
+```
+
+---
+
+## 次のステップ
+
+[Part V](part-5.md) では、STM による同期と排他制御を学びます。

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

@@ -0,0 +1,118 @@
+---
+title: Part V - 同期と排他制御
+description: STM と ref による銀行口座
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, stm
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、Clojure の STM（Software Transactional Memory）を学びます。
+
+---
+
+## Ref と dosync
+
+```clojure
+;; ref の作成
+(def balance (ref 1000))
+
+;; トランザクション内で更新
+(dosync
+  (alter balance + 100))
+
+;; 値を取得
+@balance  ;; => 1100
+```
+
+---
+
+## BankAccount 実装
+
+### 口座作成
+
+```clojure
+(defn create-account
+  "銀行口座を作成"
+  [id initial-balance]
+  {:id id
+   :balance (ref initial-balance)})
+
+(defn get-id [account] (:id account))
+(defn get-balance [account] @(:balance account))
+```
+
+---
+
+## 入出金
+
+```clojure
+(defn deposit!
+  "入金"
+  [account amount]
+  (dosync
+    (alter (:balance account) + amount)))
+
+(defn withdraw!
+  "出金（残高チェック付き）"
+  [account amount]
+  (dosync
+    (if (>= @(:balance account) amount)
+      (do
+        (alter (:balance account) - amount)
+        true)
+      false)))
+```
+
+---
+
+## 振込（デッドロックフリー）
+
+```clojure
+(defn transfer!
+  "振込（STM によるデッドロックフリー）"
+  [from to amount]
+  (dosync
+    (if (>= @(:balance from) amount)
+      (do
+        (alter (:balance from) - amount)
+        (alter (:balance to) + amount)
+        true)
+      false)))
+```
+
+---
+
+## STM の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| 自動リトライ | 競合時に自動的にリトライ |
+| デッドロックフリー | ロック順序の問題なし |
+| 一貫性 | トランザクション内は一貫 |
+| 分離性 | 他のトランザクションから分離 |
+
+---
+
+## 並行テスト
+
+```clojure
+(let [a1 (create-account 1 1000)
+      a2 (create-account 2 1000)
+      f1 (future (dotimes [_ 50] (transfer! a1 a2 1)))
+      f2 (future (dotimes [_ 50] (transfer! a2 a1 1)))]
+  @f1 @f2
+  (+ (get-balance a1) (get-balance a2)))
+;; => 2000（常に合計金額が保持される）
+```
+
+---
+
+## 次のステップ
+
+[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。

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

@@ -0,0 +1,89 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: future と promise
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, async
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、Clojure の future と promise による非同期処理を学びます。
+
+---
+
+## Future
+
+```clojure
+;; 非同期計算
+(def result (future
+              (Thread/sleep 1000)
+              (+ 1 2)))
+
+;; 結果を取得（ブロッキング）
+@result  ;; => 3
+
+;; タイムアウト付き
+(deref result 500 :timeout)
+```
+
+---
+
+## Promise
+
+```clojure
+;; Promise 作成
+(def p (promise))
+
+;; 別スレッドで値を設定
+(future
+  (Thread/sleep 100)
+  (deliver p :done))
+
+;; 結果を待機
+@p  ;; => :done
+```
+
+---
+
+## 複数の非同期タスク
+
+```clojure
+(defn fetch-all [urls]
+  (let [futures (doall (map #(future (fetch-url %)) urls))]
+    (map deref futures)))
+```
+
+---
+
+## タイムアウト処理
+
+```clojure
+(defn with-timeout [timeout-ms f]
+  (let [result (future (f))]
+    (deref result timeout-ms :timeout)))
+
+;; 使用例
+(with-timeout 1000 #(Thread/sleep 500))  ;; => nil
+(with-timeout 100 #(Thread/sleep 500))   ;; => :timeout
+```
+
+---
+
+## future vs promise
+
+| 特徴 | future | promise |
+|------|--------|---------|
+| 計算開始 | 即座に開始 | deliver まで待機 |
+| 値の設定 | 内部で計算 | 外部から deliver |
+| 用途 | 非同期計算 | スレッド間通信 |
+
+---
+
+## 次のステップ
+
+[Part VII](part-7.md) では、core.async を学びます。

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

@@ -0,0 +1,100 @@
+---
+title: Part VII - 非同期プログラミング
+description: core.async の詳細
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, core.async
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、Clojure の core.async ライブラリを詳しく学びます。
+
+---
+
+## チャネル基礎
+
+```clojure
+(require '[clojure.core.async :as async
+           :refer [chan go >! <! >!! <!! close!]])
+
+;; チャネル作成
+(def ch (chan))           ;; バッファなし
+(def ch (chan 10))        ;; バッファサイズ 10
+
+;; go ブロック内での操作
+(go (>! ch "hello"))      ;; 非ブロッキング送信
+(go (println (<! ch)))    ;; 非ブロッキング受信
+
+;; 通常スレッドでの操作
+(>!! ch "hello")          ;; ブロッキング送信
+(<!! ch)                  ;; ブロッキング受信
+```
+
+---
+
+## go ブロック
+
+```clojure
+;; 軽量スレッド（IOC スレッド）
+(go
+  (let [result (<! (async/timeout 1000))]
+    (println "1秒経過")))
+
+;; 複数の go ブロック
+(let [ch (chan)]
+  (go (>! ch 1))
+  (go (>! ch 2))
+  (go (println "受信:" (<! ch) (<! ch))))
+```
+
+---
+
+## alt! と alts!
+
+```clojure
+;; 複数チャネルから選択
+(go
+  (alt!
+    ch1 ([v] (println "ch1 から" v))
+    ch2 ([v] (println "ch2 から" v))
+    (async/timeout 1000) (println "タイムアウト")))
+```
+
+---
+
+## パイプライン
+
+```clojure
+;; async/pipeline
+(let [in (chan 10)
+      out (chan 10)]
+  (async/pipeline 4 out (map inc) in)
+  (async/onto-chan! in [1 2 3 4 5])
+  (<!! (async/into [] out)))
+;; => [2 3 4 5 6]
+```
+
+---
+
+## core.async 関数一覧
+
+| 関数 | 説明 |
+|------|------|
+| chan | チャネル作成 |
+| go | 軽量スレッド |
+| >! / <! | go 内での送受信 |
+| >!! / <!! | ブロッキング送受信 |
+| alt! | 複数チャネル選択 |
+| pipeline | 並列変換 |
+| timeout | タイムアウトチャネル |
+
+---
+
+## 次のステップ
+
+[Part VIII](part-8.md) では、MapReduce パターンを学びます。

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

@@ -0,0 +1,120 @@
+---
+title: Part VIII - 分散並列処理
+description: pmap と MapReduce パターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, mapreduce
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、pmap と MapReduce パターンを学びます。
+
+---
+
+## pmap（並列 map）
+
+```clojure
+;; 通常の map
+(map inc [1 2 3 4 5])
+
+;; 並列 map
+(pmap inc [1 2 3 4 5])
+
+;; CPU バウンドな処理に有効
+(pmap expensive-computation large-collection)
+```
+
+---
+
+## MapReduce パターン
+
+### Map フェーズ
+
+```clojure
+(require '[clojure.string :as str])
+
+(defn map-phase
+  "Map: テキストを (word, 1) ペアに変換"
+  [text]
+  (->> (str/split (str/lower-case text) #"\s+")
+       (filter (complement str/blank?))
+       (map (fn [word] [word 1]))))
+```
+
+---
+
+## Reduce フェーズ
+
+```clojure
+(defn reduce-phase
+  "Reduce: ペアを集約してワードカウント"
+  [pairs]
+  (reduce (fn [acc [word count]]
+            (update acc word (fnil + 0) count))
+          {}
+          pairs))
+```
+
+---
+
+## ワードカウント実装
+
+```clojure
+(defn count-words-sequential
+  "逐次ワードカウント"
+  [texts]
+  (->> texts
+       (mapcat map-phase)
+       reduce-phase))
+
+(defn count-words-parallel
+  "並列ワードカウント (pmap による MapReduce)"
+  [texts]
+  (if (empty? texts)
+    {}
+    (->> texts
+         (pmap map-phase)
+         (apply concat)
+         reduce-phase)))
+```
+
+---
+
+## 使用例
+
+```clojure
+(count-words-parallel
+  ["hello world" "hello clojure" "world of clojure"])
+;; => {"hello" 2, "world" 2, "clojure" 2, "of" 1}
+```
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | 純粋関数、SHA-256 |
+| II | スレッド | future、Thread |
+| III | マルチタスキング | atom、イベント同期 |
+| IV | 並列パターン | Fork/Join、Pipeline |
+| V | 同期 | STM、ref、dosync |
+| VI | ノンブロッキング | future、promise |
+| VII | 非同期 | core.async |
+| VIII | 分散処理 | pmap、MapReduce |
+
+---
+
+## 参考資料
+
+- [Clojure Reference: Atoms](https://clojure.org/reference/atoms)
+- [Clojure Reference: Refs and Transactions](https://clojure.org/reference/refs)
+- [core.async Guide](https://clojure.org/guides/async_walkthrough)
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)