thread::spawn — スレッドを起動するのサンプルコード — Rust

1最小の spawn — 起動して join で待つ

thread::spawn にクロージャを渡すと別スレッドで動き、handle.join() で完了を待って返り値を受け取れる、最小の往復です。spawn した直後にメインはもう次の行へ進めるのがポイントで、join はあくまで「結果が要るときに待つ」ための呼び出しです。まずはこの3手(起動→続行→join)の流れを体に入れてください。

Rust

use std::thread;

fn main() {
    // クロージャの処理が新しいスレッドで動く
    let handle = thread::spawn(|| 21 * 2);

    println!("メインスレッドは待たずに次の行へ進める");

    let answer = handle.join().unwrap(); // 終わるまで待って返り値を受け取る
    println!("スレッドの答え = {}", answer);
}

2スレッドの返り値 — String を作って返す

スレッドの返り値は整数に限らず、クロージャの最後の式の値ならどんな型でも join で受け取れることを示す例です。スレッド内で組み立てた String が所有権ごと返ってくるので、コピーも共有も発生しません。実務でも「ワーカーが作った結果オブジェクトを join でもらう」のが基本の形です。

Rust

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        let mut report = String::new();
        for i in 1..=3 {
            report.push_str(&format!("項目{} OK / ", i));
        }
        report // 作った String を所有権ごと返す
    });

    let report = handle.join().unwrap();
    println!("受け取ったレポート: {}", report);
    println!("長さ = {} バイト", report.len());
}

32本のスレッドで手分けする

同じ形の計算を範囲で2分割し、2本のスレッドに同時に走らせる並列化の最小形です。それぞれの join の返り値を足せば、1本で計算した場合と同じ答えになります。大きな集計やバッチ処理を分担させる発想の出発点です。

Rust

use std::thread;

fn main() {
    // 1〜1000 の合計を前半と後半で手分けする
    let first = thread::spawn(|| (1..=500u64).sum::<u64>());
    let second = thread::spawn(|| (501..=1000u64).sum::<u64>());

    let a = first.join().unwrap();
    let b = second.join().unwrap();
    println!("前半 = {}, 後半 = {}", a, b);
    println!("合計 = {}", a + b);
}

4JoinHandle を Vec で管理する

スレッドの本数が増えたら、JoinHandle を Vec にためて最後にまとめて join するのが定番の形です。join する順番はコード側で決まっているので、表示順は実行ごとに変わりません。素数数えのような CPU を使う処理は、こうして分担する効果が出やすい代表例です。

Rust

use std::thread;

fn is_prime(n: u32) -> bool {
    n >= 2 && (2..n).take_while(|d| d * d <= n).all(|d| n % d != 0)
}

fn main() {
    let mut handles = Vec::new();
    handles.push(thread::spawn(|| (2..1700).filter(|&n| is_prime(n)).count()));
    handles.push(thread::spawn(|| (1700..3400).filter(|&n| is_prime(n)).count()));
    handles.push(thread::spawn(|| (3400..5000).filter(|&n| is_prime(n)).count()));
    let mut total = 0;
    for (i, handle) in handles.into_iter().enumerate() {
        let count = handle.join().unwrap();
        println!("担当{}: 素数 {} 個", i + 1, count);
        total += count;
    }
    println!("5000未満の素数は合計 {} 個", total);
}

5複数ログの行数を並列集計(風)

ログファイルごとに1スレッドを立てて行数を数える、実務の並列集計を模した例です(ファイル読み込みは固定データを返す関数で代用しています)。重い読み込みや解析が複数あるとき、それぞれをスレッドに任せて join で回収する、この形がそのまま使えます。

Rust

use std::thread;

// 本来はファイル読み込みになる部分(固定データで代用)
fn load_access_log() -> String {
    String::from("GET /\nGET /about\nPOST /login\nGET /items\n")
}

fn load_app_log() -> String {
    String::from("INFO start\nERROR timeout\nINFO done\n")
}

fn main() {
    let access = thread::spawn(|| load_access_log().lines().count());
    let app = thread::spawn(|| load_app_log().lines().count());

    let a = access.join().unwrap();
    let b = app.join().unwrap();
    println!("access.log: {} 行 / app.log: {} 行", a, b);
    println!("合計 {} 行を2スレッドで数えた", a + b);
}

サンプルコードで身につける: thread::spawn — スレッドを起動する

1最小の spawn — 起動して join で待つ

2スレッドの返り値 — String を作って返す

32本のスレッドで手分けする

4JoinHandle を Vec で管理する

5複数ログの行数を並列集計(風)