第23章多线程 on 编程那些事儿

01-多线程基础

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/threads/basic-using.html

多线程基础

使用 std::thread::spawn 创建新线程，用 JoinHandle 的 join 等待线程结束。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 让代码工作
use std::thread;
use std::time::Duration;

fn main() {
 thread::spawn(|| {
 for i in 1..3 {
 println!("hi number {} from the spawned thread", i);
 thread::sleep(Duration::from_millis(1));
 }
 });

 for i in 1..3 {
 println!("hi number {} from the main thread", i);
 thread::sleep(Duration::from_millis(1));
 }
 println!("Success!");
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 让代码工作：主线程应等待子线程结束
use std::thread;
use std::time::Duration;

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

 __;

 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 让代码工作
use std::thread;

fn main() {
 let v = vec![1, 2, 3];

 let handle = thread::spawn(move || {
 println!("Here's a vector: {:?}", v);
 });

 handle.join().unwrap();
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 填空
use std::thread;

fn main() {
 let s = String::from("hello");

 let handle = thread::spawn(move || {
 println!("{}", s);
 });

 // 取消下面这行的注释并修复错误
 // println!("{}", s);

 handle.join().unwrap();
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

02-消息传递

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/threads/message-passing.html

消息传递

Rust 鼓励通过消息传递在线程间通信。std::sync::mpsc 提供多生产者、单消费者通道。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 让代码工作
use std::sync::mpsc;
use std::thread;

fn main() {
 let (tx, rx) = mpsc::channel();

 thread::spawn(move || {
 let val = String::from("hi");
 tx.send(val).unwrap();
 });

 let received = rx.recv().unwrap();
 assert_eq!(received, "hi");
 println!("Success!");
}

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


// 让代码工作
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
 let (tx, rx) = mpsc::channel();

 thread::spawn(move || {
 let vals = vec![
 String::from("hi"),
 String::from("from"),
 String::from("the"),
 String::from("thread"),
 ];

 for val in vals {
 tx.send(val).unwrap();
 thread::sleep(Duration::from_secs(1));
 }
 });

 for received in rx {
 println!("Got: {}", received);
 }
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 让代码工作：克隆发送端，多个线程发送消息
use std::sync::mpsc;
use std::thread;

fn main() {
 let (tx, rx) = mpsc::channel();
 let tx1 = tx.clone();

 thread::spawn(move || {
 tx.send(String::from("hi")).unwrap();
 });

 thread::spawn(move || {
 tx1.send(String::from("from")).unwrap();
 });

 for received in rx {
 println!("Got: {}", received);
 }
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 填空
use std::sync::mpsc;
use std::thread;

fn main() {
 let (tx, rx) = mpsc::channel();

 thread::spawn(move || {
 for i in 0..3 {
 tx.send(i).unwrap();
 }
 });

 assert_eq!(rx.recv().unwrap(), 0);
 assert_eq!(rx.recv().unwrap(), 1);
 assert_eq!(__, 2);
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

03-线程同步：锁、Condvar和信号量

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/threads/sync.html

线程同步：锁、Condvar和信号量

多线程共享可变数据时，常用 Mutex<T> 配合 Arc<T> 实现安全共享。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 让代码工作
use std::sync::Mutex;

fn main() {
 let m = Mutex::new(5);

 {
 let mut num = m.lock().unwrap();
 *num = 6;
 }

 assert_eq!(*m.lock().unwrap(), 6);
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 让代码工作
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
 let counter = Arc::new(Mutex::new(0));
 let mut handles = vec![];

 for _ in 0..10 {
 let counter = Arc::clone(&counter);
 let handle = thread::spawn(move || {
 let mut num = counter.lock().unwrap();
 *num += 1;
 });
 handles.push(handle);
 }

 for handle in handles {
 handle.join().unwrap();
 }

 assert_eq!(*counter.lock().unwrap(), 10);
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 填空
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
 let data = Arc::new(Mutex::new(vec![]));
 let mut handles = vec![];

 for i in 0..3 {
 let data = Arc::clone(&data);
 handles.push(thread::spawn(move || {
 let mut v = data.lock().unwrap();
 v.push(i);
 }));
 }

 for h in handles {
 h.join().unwrap();
 }

 let v = data.lock().unwrap();
 assert_eq!(v.len(), 3);
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

04-线程同步：Atomic

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/threads/atomic.html

线程同步：Atomic

Atomic* 类型提供无锁原子操作，适合简单的计数器等场景。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 让代码工作
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

fn main() {
 let counter = Arc::new(AtomicUsize::new(0));
 let mut handles = vec![];

 for _ in 0..10 {
 let counter = Arc::clone(&counter);
 handles.push(thread::spawn(move || {
 counter.fetch_add(1, Ordering::SeqCst);
 }));
 }

 for h in handles {
 h.join().unwrap();
 }

 assert_eq!(counter.load(Ordering::SeqCst), 10);
 println!("Success!");
}

🌟🌟

1
2
3
4
5
6
7
8
9


// 填空
use std::sync::atomic::{AtomicBool, Ordering};

fn main() {
 let flag = AtomicBool::new(false);
 flag.store(true, Ordering::Relaxed);
 assert_eq!(flag.load(__), true);
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 让代码工作
use std::sync::atomic::{AtomicI32, Ordering};
use std::sync::Arc;
use std::thread;

fn main() {
 let sum = Arc::new(AtomicI32::new(0));
 let mut handles = vec![];

 for i in 1..=5 {
 let sum = Arc::clone(&sum);
 handles.push(thread::spawn(move || {
 sum.fetch_add(i, Ordering::SeqCst);
 }));
 }

 for h in handles {
 h.join().unwrap();
 }

 assert_eq!(sum.load(Ordering::SeqCst), 15);
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

05-Send 和 Sync

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust.beatai.org/threads/send-sync.html

Send 和 Sync

Send 表示类型可以安全地在线程间转移所有权；Sync 表示类型可以安全地在线程间共享引用。

🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 以下代码能否编译？若不能，说明原因并修复
use std::thread;

fn main() {
 let v = vec![1, 2, 3];
 let handle = thread::spawn(move || {
 println!("{:?}", v);
 });
 handle.join().unwrap();
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 让代码工作：`Rc` 不是 `Send`，应改用 `Arc`
use std::sync::Arc;
use std::thread;

fn main() {
 let data = Arc::new(5);
 let data2 = Arc::clone(&data);

 let handle = thread::spawn(move || {
 println!("{}", data2);
 });

 handle.join().unwrap();
 println!("{}", data);
 println!("Success!");
}

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 填空：`Mutex` 保护的类型是 `Sync` 的
use std::sync::{Arc, Mutex};
use std::thread;

fn is_send<T: Send>() {}
fn is_sync<T: Sync>() {}

fn main() {
 is_send::<Arc<Mutex<i32>>>();
 is_sync::<Arc<__>>();
 println!("Success!");
}

你可以在这里找到答案（在 solutions 路径下），但请只在需要时使用

第23章 多线程 on 编程那些事儿

01-多线程基础

多线程基础

02-消息传递

消息传递

03-线程同步：锁、Condvar和信号量

线程同步：锁、Condvar和信号量

04-线程同步：Atomic

线程同步：Atomic

05-Send 和 Sync

Send 和 Sync

第23章多线程 on 编程那些事儿