@k2works/claude-code-booster 6.2.0 → 6.3.1

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

@@ -1,119 +0,0 @@
----
-type: Article
-title: "Part II - プロセスとスレッド"
-description: "std::thread によるスレッド操作"
-tags: [article, grokking-concurrency, rust, concurrency, thread]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,125 +0,0 @@
----
-type: Article
-title: "Part III - マルチタスキングとスケジューリング"
-description: "ゲームループと協調マルチタスキング"
-tags: [article, grokking-concurrency, rust, concurrency, multitasking]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,174 +0,0 @@
----
-type: Article
-title: "Part IV - タスク分解と並列パターン"
-description: "Fork/Join と Pipeline パターン"
-tags: [article, grokking-concurrency, rust, concurrency, forkjoin, pipeline]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,157 +0,0 @@
----
-type: Article
-title: "Part V - 同期と排他制御"
-description: "Mutex と Arc によるスレッドセーフな実装"
-tags: [article, grokking-concurrency, rust, concurrency, synchronization, mutex]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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 を学びます。

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

@@ -1,93 +0,0 @@
----
-type: Article
-title: "Part VI - ノンブロッキング I/O"
-description: "async/await によるノンブロッキング処理"
-tags: [article, grokking-concurrency, rust, concurrency, async, tokio]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VI: ノンブロッキング I/O
-
-## 概要
-
-本章では、Rust の async/await を使用したノンブロッキング I/O を学びます。
-
----
-
-## ブロッキング vs ノンブロッキング
-
-### ブロッキング I/O
-
-```rust
-use std::fs;
-
-// スレッドは I/O 完了まで待機
-let content = fs::read_to_string("file.txt").unwrap();
-```
-
-### ノンブロッキング I/O (async)
-
-```rust
-use tokio::fs;
-
-async fn read_file_async(path: &str) -> String {
-    fs::read_to_string(path).await.unwrap()
-}
-```
-
----
-
-## Tokio の基本
-
-```rust
-use tokio;
-
-#[tokio::main]
-async fn main() {
-    let result = fetch_data("https://example.com").await;
-    println!("{}", result);
-}
-
-async fn fetch_data(url: &str) -> String {
-    // 非同期 HTTP リクエスト
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    format!("Data from {}", url)
-}
-```
-
----
-
-## 並行実行
-
-```rust
-use tokio;
-
-#[tokio::main]
-async fn main() {
-    // 並行実行
-    let (r1, r2, r3) = tokio::join!(
-        fetch_data("url1"),
-        fetch_data("url2"),
-        fetch_data("url3"),
-    );
-
-    println!("{}, {}, {}", r1, r2, r3);
-}
-```
-
----
-
-## メリット
-
-| 項目 | ブロッキング | async |
-|------|-------------|-------|
-| スレッド消費 | 待機中も占有 | 解放 |
-| スケーラビリティ | 低い | 高い |
-| コード複雑さ | 低い | やや高い |
-
----
-
-## 次のステップ
-
-[Part VII](part-7.md) では、非同期プログラミングの詳細を学びます。