@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,108 @@
+---
+title: Part I - 並行処理の基礎
+description: 逐次処理とパスワードクラッカーの実装
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, sequential, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part I: 並行処理の基礎
+
+## 概要
+
+本章では、並行処理の基礎として逐次処理を学びます。
+
+---
+
+## パスワードクラッカーの実装
+
+### SHA-256 ハッシュ計算
+
+```rust
+use sha2::{Sha256, Digest};
+
+/// Compute SHA-256 hash of a password
+pub fn get_crypto_hash(password: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(password.as_bytes());
+    let result = hasher.finalize();
+    format!("{:x}", result)
+}
+```
+
+---
+
+### ブルートフォース探索
+
+```rust
+/// Crack password by brute force (sequential)
+pub fn crack_password(
+    crypto_hash: &str,
+    alphabet: &[char],
+    length: usize,
+) -> Option<String> {
+    if length == 0 {
+        return None;
+    }
+    crack_recursive(crypto_hash, alphabet, String::new(), length)
+}
+
+fn crack_recursive(
+    crypto_hash: &str,
+    alphabet: &[char],
+    prefix: String,
+    remaining: usize,
+) -> Option<String> {
+    if remaining == 0 {
+        if get_crypto_hash(&prefix) == crypto_hash {
+            return Some(prefix);
+        }
+        return None;
+    }
+
+    for &c in alphabet {
+        let mut candidate = prefix.clone();
+        candidate.push(c);
+        if let Some(result) = crack_recursive(
+            crypto_hash, alphabet, candidate, remaining - 1
+        ) {
+            return Some(result);
+        }
+    }
+    None
+}
+```
+
+---
+
+## 使用例
+
+```rust
+fn main() {
+    let alphabet: Vec<char> = "ab".chars().collect();
+    let target_hash = get_crypto_hash("ab");
+
+    match crack_password(&target_hash, &alphabet, 2) {
+        Some(password) => println!("Found: {}", password),
+        None => println!("Not found"),
+    }
+}
+```
+
+---
+
+## Rust の特徴
+
+| 概念 | 説明 |
+|------|------|
+| Option<T> | 値が存在しない可能性を表現 |
+| Iterator | 遅延評価による効率的な処理 |
+| 所有権 | メモリ安全性の保証 |
+
+---
+
+## 次のステップ
+
+[Part II](part-2.md) では、スレッドを使った並行処理を学びます。

package/lib/assets/docs/article/grokking-concurrency/rust/part-2.md

@@ -0,0 +1,120 @@
+---
+title: Part II - プロセスとスレッド
+description: std::thread によるスレッド操作
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, thread, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、Rust の std::thread を使ったスレッド操作を学びます。
+
+---
+
+## スレッドの基本
+
+### スレッドの作成
+
+```rust
+use std::thread::{self, JoinHandle};
+
+/// Create and start a new thread
+pub fn create_thread<F>(f: F) -> JoinHandle<()>
+where
+    F: FnOnce() + Send + 'static,
+{
+    thread::spawn(f)
+}
+```
+
+---
+
+### 複数スレッドの実行
+
+```rust
+/// Run multiple threads and wait for completion
+pub fn run_threads<F>(count: usize, f: F)
+where
+    F: Fn(usize) + Send + Sync + Clone + 'static,
+{
+    let handles: Vec<_> = (0..count)
+        .map(|i| {
+            let f = f.clone();
+            thread::spawn(move || f(i))
+        })
+        .collect();
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+}
+```
+
+---
+
+## 並列パスワードクラッカー
+
+```rust
+use rayon::prelude::*;
+
+/// Crack password using parallel execution with Rayon
+pub fn crack_password_parallel(
+    crypto_hash: &str,
+    alphabet: &[char],
+    length: usize,
+) -> Option<String> {
+    if length == 0 {
+        return None;
+    }
+
+    let first_chars: Vec<char> = alphabet.to_vec();
+
+    first_chars
+        .par_iter()
+        .find_map_any(|&first| {
+            crack_recursive(crypto_hash, alphabet, first.to_string(), length - 1)
+        })
+}
+```
+
+---
+
+## Send と Sync トレイト
+
+| トレイト | 説明 | 例 |
+|----------|------|-----|
+| Send | 所有権を別スレッドに移動可能 | 多くの型 |
+| Sync | 参照を複数スレッドで共有可能 | &T where T: Send |
+| !Send | スレッド間移動不可 | Rc<T> |
+| !Sync | 参照共有不可 | Cell<T> |
+
+---
+
+## 使用例
+
+```rust
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+
+fn main() {
+    let counter = Arc::new(AtomicUsize::new(0));
+
+    let counter_clone = Arc::clone(&counter);
+    run_threads(5, move |_| {
+        counter_clone.fetch_add(1, Ordering::SeqCst);
+    });
+
+    println!("Count: {}", counter.load(Ordering::SeqCst)); // 5
+}
+```
+
+---
+
+## 次のステップ
+
+[Part III](part-3.md) では、マルチタスキングとゲームループを学びます。

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

@@ -0,0 +1,126 @@
+---
+title: Part III - マルチタスキングとスケジューリング
+description: ゲームループと協調マルチタスキング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, multitasking, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、ゲームループを例にマルチタスキングを学びます。
+
+---
+
+## ゲームタスク
+
+```rust
+/// A game task that can be processed
+pub struct GameTask {
+    pub name: String,
+    pub action: Box<dyn Fn() + Send + Sync>,
+}
+
+impl GameTask {
+    pub fn new<F>(name: &str, action: F) -> Self
+    where
+        F: Fn() + Send + Sync + 'static,
+    {
+        GameTask {
+            name: name.to_string(),
+            action: Box::new(action),
+        }
+    }
+
+    pub fn execute(&self) {
+        (self.action)();
+    }
+}
+```
+
+---
+
+## プロセッサフリーイベント
+
+```rust
+use std::sync::{Condvar, Mutex};
+
+/// Event for signaling processor availability
+pub struct ProcessorFreeEvent {
+    state: Mutex<bool>,
+    condvar: Condvar,
+}
+
+impl ProcessorFreeEvent {
+    pub fn new() -> Self {
+        ProcessorFreeEvent {
+            state: Mutex::new(false),
+            condvar: Condvar::new(),
+        }
+    }
+
+    pub fn wait(&self) {
+        let mut ready = self.state.lock().unwrap();
+        while !*ready {
+            ready = self.condvar.wait(ready).unwrap();
+        }
+        *ready = false;
+    }
+
+    pub fn signal(&self) {
+        let mut ready = self.state.lock().unwrap();
+        *ready = true;
+        self.condvar.notify_one();
+    }
+}
+```
+
+---
+
+## ゲームループ
+
+```rust
+/// Simple game loop that processes tasks
+pub fn game_loop(tasks: Vec<GameTask>, iterations: usize) {
+    for _ in 0..iterations {
+        for task in &tasks {
+            task.execute();
+        }
+    }
+}
+
+/// Cooperative game loop with event signaling
+pub fn cooperative_game_loop(
+    tasks: Vec<Arc<GameTask>>,
+    event: Arc<ProcessorFreeEvent>,
+    iterations: usize,
+) {
+    for _ in 0..iterations {
+        for task in &tasks {
+            task.execute();
+            event.signal();
+            thread::yield_now();
+        }
+    }
+}
+```
+
+---
+
+## Condvar の使い方
+
+| メソッド | 説明 |
+|----------|------|
+| wait(guard) | シグナルを待機 |
+| notify_one() | 1つのスレッドを起床 |
+| notify_all() | 全スレッドを起床 |
+
+---
+
+## 次のステップ
+
+[Part IV](part-4.md) では、Fork/Join と Pipeline パターンを学びます。

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

@@ -0,0 +1,175 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: Fork/Join と Pipeline パターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, forkjoin, pipeline, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、Fork/Join と Pipeline パターンを学びます。
+
+---
+
+## Fork/Join パターン
+
+### 投票カウンター
+
+```rust
+use rayon::prelude::*;
+use std::collections::HashMap;
+
+/// Vote Counter using Fork/Join pattern
+pub fn count_votes(votes: &[&str]) -> HashMap<String, usize> {
+    if votes.is_empty() {
+        return HashMap::new();
+    }
+
+    // Use parallel fold and reduce
+    votes
+        .par_iter()
+        .fold(
+            || HashMap::new(),
+            |mut acc: HashMap<String, usize>, &vote| {
+                *acc.entry(vote.to_string()).or_insert(0) += 1;
+                acc
+            },
+        )
+        .reduce(
+            || HashMap::new(),
+            |mut a, b| {
+                for (k, v) in b {
+                    *a.entry(k).or_insert(0) += v;
+                }
+                a
+            },
+        )
+}
+```
+
+---
+
+## Pipeline パターン
+
+### Pipeline 構造体
+
+```rust
+/// Pipeline that processes items through multiple stages
+pub struct Pipeline {
+    stages: Vec<Box<dyn Fn(i32) -> i32 + Send>>,
+}
+
+impl Pipeline {
+    pub fn new() -> Self {
+        Pipeline { stages: Vec::new() }
+    }
+
+    pub fn add_stage<F>(mut self, processor: F) -> Self
+    where
+        F: Fn(i32) -> i32 + Send + 'static,
+    {
+        self.stages.push(Box::new(processor));
+        self
+    }
+
+    pub fn process(&self, input: i32) -> i32 {
+        self.stages.iter().fold(input, |acc, stage| stage(acc))
+    }
+}
+```
+
+---
+
+### チャネルによる並行パイプライン
+
+```rust
+use std::sync::mpsc::{channel, Receiver, Sender};
+use std::thread;
+
+/// Concurrent pipeline using channels
+pub fn concurrent_pipeline<T>(
+    input: Vec<T>,
+    processors: Vec<Box<dyn Fn(T) -> T + Send + 'static>>,
+) -> Vec<T>
+where
+    T: Send + 'static + Clone,
+{
+    if processors.is_empty() {
+        return input;
+    }
+
+    let (first_tx, mut current_rx): (Sender<T>, Receiver<T>) = channel();
+
+    // Send initial input
+    let input_thread = thread::spawn(move || {
+        for item in input {
+            first_tx.send(item).unwrap();
+        }
+    });
+
+    // Create processor threads
+    let mut handles = vec![input_thread];
+
+    for processor in processors {
+        let (tx, rx): (Sender<T>, Receiver<T>) = channel();
+        let prev_rx = current_rx;
+        current_rx = rx;
+
+        let handle = thread::spawn(move || {
+            while let Ok(item) = prev_rx.recv() {
+                let result = processor(item);
+                if tx.send(result).is_err() {
+                    break;
+                }
+            }
+        });
+        handles.push(handle);
+    }
+
+    // Collect results
+    let mut results = Vec::new();
+    while let Ok(item) = current_rx.recv() {
+        results.push(item);
+    }
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    results
+}
+```
+
+---
+
+## 使用例
+
+```rust
+fn main() {
+    // Pipeline
+    let pipeline = Pipeline::new()
+        .add_stage(|x| x + 1)
+        .add_stage(|x| x * 2)
+        .add_stage(|x| x - 3);
+
+    let result = pipeline.process(5);
+    // (5 + 1) * 2 - 3 = 9
+    println!("Result: {}", result);
+
+    // Fork/Join
+    let votes = vec!["A", "B", "A", "A", "B", "C"];
+    let counts = count_votes(&votes);
+    // {"A": 3, "B": 2, "C": 1}
+}
+```
+
+---
+
+## 次のステップ
+
+[Part V](part-5.md) では、同期と排他制御を学びます。

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

@@ -0,0 +1,158 @@
+---
+title: Part V - 同期と排他制御
+description: Mutex と Arc によるスレッドセーフな実装
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, synchronization, mutex, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、銀行口座を例に Mutex と Arc を使った同期を学びます。
+
+---
+
+## 銀行口座構造体
+
+```rust
+use std::sync::{Arc, Mutex};
+
+/// A thread-safe bank account
+#[derive(Debug)]
+pub struct BankAccount {
+    balance: Mutex<i64>,
+    id: usize,
+}
+
+impl BankAccount {
+    pub fn new(initial_balance: i64) -> Self {
+        static COUNTER: std::sync::atomic::AtomicUsize =
+            std::sync::atomic::AtomicUsize::new(0);
+        BankAccount {
+            balance: Mutex::new(initial_balance),
+            id: COUNTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst),
+        }
+    }
+
+    pub fn get_balance(&self) -> i64 {
+        *self.balance.lock().unwrap()
+    }
+
+    pub fn deposit(&self, amount: i64) {
+        let mut balance = self.balance.lock().unwrap();
+        *balance += amount;
+    }
+
+    pub fn withdraw(&self, amount: i64) -> bool {
+        let mut balance = self.balance.lock().unwrap();
+        if *balance >= amount {
+            *balance -= amount;
+            true
+        } else {
+            false
+        }
+    }
+}
+```
+
+---
+
+## デッドロック回避
+
+```rust
+/// Transfer money between accounts atomically, avoiding deadlock
+pub fn transfer(
+    from: &Arc<BankAccount>,
+    to: &Arc<BankAccount>,
+    amount: i64,
+) -> bool {
+    // Always lock in consistent order to avoid deadlock
+    let (first, second, from_is_first) = if from.id < to.id {
+        (from, to, true)
+    } else {
+        (to, from, false)
+    };
+
+    let mut first_guard = first.balance.lock().unwrap();
+    let mut second_guard = second.balance.lock().unwrap();
+
+    let (from_guard, to_guard) = if from_is_first {
+        (&mut first_guard, &mut second_guard)
+    } else {
+        (&mut second_guard, &mut first_guard)
+    };
+
+    if **from_guard >= amount {
+        **from_guard -= amount;
+        **to_guard += amount;
+        true
+    } else {
+        false
+    }
+}
+```
+
+---
+
+## 同期プリミティブ
+
+| 型 | 説明 |
+|----|------|
+| Mutex<T> | 排他ロック |
+| RwLock<T> | 読み書きロック |
+| Arc<T> | アトミック参照カウント |
+| AtomicUsize | アトミック整数 |
+
+---
+
+## デッドロック回避戦略
+
+1. **一貫したロック順序** - ID でソートしてロック
+2. **try_lock** - ロック取得失敗時にリトライ
+3. **タイムアウト** - 一定時間でロック解除
+
+---
+
+## 使用例
+
+```rust
+use std::thread;
+
+fn main() {
+    let account1 = Arc::new(BankAccount::new(1000));
+    let account2 = Arc::new(BankAccount::new(1000));
+
+    let mut handles = vec![];
+
+    for i in 0..20 {
+        let a1 = Arc::clone(&account1);
+        let a2 = Arc::clone(&account2);
+
+        handles.push(thread::spawn(move || {
+            if i % 2 == 0 {
+                transfer(&a1, &a2, 10);
+            } else {
+                transfer(&a2, &a1, 10);
+            }
+        }));
+    }
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    // Total remains 2000
+    let total = account1.get_balance() + account2.get_balance();
+    assert_eq!(total, 2000);
+}
+```
+
+---
+
+## 次のステップ
+
+[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。