サンプルコードで身につける: Mutex と Arc — 共有状態を安全に更新する

use std::sync::Mutex;

fn main() {
    let score = Mutex::new(10);

    {
        let mut value = score.lock().unwrap(); // ロックを取って中身を借りる
        *value += 5;
    } // value が消えた瞬間にロックが解放される

    println!("score = {}", *score.lock().unwrap());
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();

    for _ in 0..4 {
        let counter = Arc::clone(&counter); // 所有者を増やして配る
        handles.push(thread::spawn(move || {
            for _ in 0..100 {
                *counter.lock().unwrap() += 1; // 1回ずつロックして加算
            }
        }));
    }
    for handle in handles { handle.join().unwrap(); }
    println!("最終カウント = {}", *counter.lock().unwrap()); // 必ず 400
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let results = Arc::new(Mutex::new(Vec::new()));
    let mut handles = Vec::new();

    for id in 1..=3 {
        let results = Arc::clone(&results);
        handles.push(thread::spawn(move || {
            results.lock().unwrap().push(id * 10); // 共有の Vec に追加
        }));
    }
    for handle in handles { handle.join().unwrap(); }

    let mut list = results.lock().unwrap();
    list.sort(); // push された順番は不定なので並べ直す
    println!("結果一覧: {:?}", *list);
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let total = Arc::new(Mutex::new(0u64));
    let mut handles = Vec::new();

    for start in vec![1u64, 1001, 2001] {
        let total = Arc::clone(&total);
        handles.push(thread::spawn(move || {
            let sub: u64 = (start..start + 1000).sum(); // 重い計算はロックの外で
            *total.lock().unwrap() += sub; // ロックは足し込む一瞬だけ
        }));
    }
    for handle in handles { handle.join().unwrap(); }
    println!("1〜3000 の合計 = {}", *total.lock().unwrap());
}

use std::{collections::HashMap, sync::{Arc, Mutex}, thread};

fn main() {
    let counts = Arc::new(Mutex::new(HashMap::new()));
    let pages = vec!["rust is fast", "rust is safe", "fast and safe"];
    let mut handles = Vec::new();
    for page in pages {
        let counts = Arc::clone(&counts);
        handles.push(thread::spawn(move || {
            for word in page.split_whitespace() {
                *counts.lock().unwrap().entry(word).or_insert(0) += 1;
            }
        }));
    }
    for handle in handles { handle.join().unwrap(); }
    let map = counts.lock().unwrap();
    let mut words: Vec<_> = map.iter().collect();
    words.sort();
    for (word, n) in words { println!("{}: {} 回", word, n); }
}