Learn Rust Coding · 课时

创建线程

Q: 「创建线程」这节课中我会学到什么？

并发运行代码。 你通过在浏览器中直接运行的动手代码来练习 Learn Rust Coding，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

并发运行代码。

创建线程 是 CoddyKit 上的免费 Learn Rust Coding 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Learn Rust Coding 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Learn Rust Coding 课程共包含 4 节课。

什么是线程

线程可以让程序并发运行代码。操作系统可以调度多个线程，因此不同工作可以重叠执行。

Rust 的标准库通过 std::thread 模块提供线程功能。这些是原生操作系统线程，有时也称为一对一线程。

在本课中，您将学习如何启动新线程，以及如何控制它们的运行方式。

使用 thread::spawn 创建线程

调用 thread::spawn 并向其传入闭包，即可创建新线程。闭包包含新线程要运行的代码。

调用会立即返回一个 JoinHandle，而新创建的线程会在后台运行。

use std::thread;

fn main() {
    thread::spawn(|| {
        println!("hello from a thread");
    });
    println!("hello from main");
}

主线程可能先结束

当 main 返回时，整个进程都会结束，即使创建的线程仍在运行。

因此，上面的程序可能只打印主线程的消息。后台线程可能还没来得及运行，进程就已经退出了。

我们需要一种等待线程完成的方法。

使用 join 等待

spawn 返回的 JoinHandle 有一个 join 方法。调用它会阻塞当前线程，直到创建的线程完成。

这样可以保证创建的线程运行完成后，主线程才会继续执行。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("worker done");
    });
    handle.join().unwrap();
    println!("main done");
}

交错输出

两个线程同时运行时，它们的输出可能以不可预测的方式交错。调度顺序由操作系统决定。

两次运行同一个程序可能得到不同的输出顺序。没有同步机制时，绝不要依赖某个特定顺序。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..4 {
            println!("thread: {}", i);
        }
    });
    for i in 1..4 {
        println!("main: {}", i);
    }
    handle.join().unwrap();
}

使用 sleep 暂停

您可以使用 thread::sleep 暂停线程，它接收一个 Duration。这会让出 CPU，使其他线程能够继续执行。

在示例中，休眠有助于让交错执行更加明显，但在实际同步中应避免使用它。

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..4 {
            println!("spawned: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    thread::sleep(Duration::from_millis(10));
}

创建多个线程

您可以在循环中创建多个线程，并将它们的句柄收集到一个向量中。

之后遍历这个向量并对每个句柄调用 join，确保所有线程都在线程结束前完成。

use std::thread;

fn main() {
    let mut handles = vec![];
    for id in 0..3 {
        let h = thread::spawn(move || {
            println!("thread {}", id);
        });
        handles.push(h);
    }
    for h in handles {
        h.join().unwrap();
    }
}

使用 Builder 命名线程

thread::Builder 类型让您可以在创建线程前对其进行配置。您可以设置线程名称和栈大小。

命名线程可以让崩溃消息和调试信息更易于阅读。

use std::thread;

fn main() {
    let h = thread::Builder::new()
        .name("worker".into())
        .spawn(|| {
            println!("running in named thread");
        })
        .unwrap();
    h.join().unwrap();
}

崩溃只会留在线程中

如果创建的线程发生崩溃，默认情况下不会导致整个程序崩溃。崩溃会被限制在该线程中。

对发生崩溃的线程调用 join 时，您会得到一个 Err。这样父线程就能检测到失败。

use std::thread;

fn main() {
    let h = thread::spawn(|| {
        panic!("boom");
    });
    let result = h.join();
    println!("joined, is_err = {}", result.is_err());
}

当前线程信息

您可以使用 thread::current 检查正在运行的线程。它会返回一个句柄，其 name 方法可以提供可选的线程名称。

主线程同样是真实的线程，通常命名为 main。

use std::thread;

fn main() {
    let current = thread::current();
    println!("name: {:?}", current.name());
}

从线程返回值

传给 spawn 的闭包可以返回一个值。调用 join 时，这个值会被包装在 Ok 中返回。

这是在另一个线程中完成计算、稍后读取结果的一种简单方式。

use std::thread;

fn main() {
    let h = thread::spawn(|| {
        let sum: i32 = (1..=10).sum();
        sum
    });
    let total = h.join().unwrap();
    println!("total = {}", total);
}

快速检查

检验您对创建线程的理解。

回顾

您已经学习了如何使用 thread::spawn 和闭包启动线程；该调用会返回一个 JoinHandle。

调用 join 会等待线程完成，并取得其返回值或检测到崩溃。不同线程的输出可能以不可预测的方式交错，而 Builder 可以让您为线程命名。

接下来，您将学习如何把数据移入所创建的线程。

常见问题解答

「创建线程」课时是免费的吗？

是的 — 「创建线程」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Learn Rust Coding 课程的其余内容，请升级到 CoddyKit PRO。 Learn Rust Coding 课程共包含 4 节课。

「创建线程」这节课中我会学到什么？

并发运行代码。你通过在浏览器中直接运行的动手代码来练习 Learn Rust Coding，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Learn Rust Coding 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Learn Rust Coding 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「创建线程」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Learn Rust Coding 课中编写并运行代码吗？

能。每节 Learn Rust Coding 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Learn Rust Coding