1. 线程和并发
Rust 的标准库提供了创建和管理线程的功能。你可以使用 std::thread 模块来创建新线程。以下是一个简单的例子：
use std::thread;
fn main() {
// 创建新线程
let handle = thread::spawn(|| {
// 在新线程中执行的代码
println!("Hello from a new thread!");
});
// 等待新线程结束
handle.join().unwrap();
// 在主线程中执行的代码
println!("Hello from the main thread!");
}
2. 消息传递
Rust 通过通道（channel）提供了一种线程之间安全地传递消息的方式。通道允许一个线程将数据发送到另一个线程。以下是一个简单的例子：
use std::sync::mpsc;
use std::thread;
fn main() {
// 创建一个通道
let (tx, rx) = mpsc::channel();
// 在新线程中发送消息
thread::spawn(move || {
let message = "Hello from another thread!";
tx.send(message).unwrap();
});
// 在主线程中接收消息
let received = rx.recv().unwrap();
println!("{}", received);
}
3. 共享状态
Rust 使用 std::sync 模块提供的原子类型和互斥体（Mutex）等工具来支持线程间的共享状态。互斥体确保只有一个线程能够访问共享数据，防止数据竞争。以下是一个使用互斥体的简单例子：
use std::sync::{Mutex, Arc};
use std::thread;
fn main() {
// 创建一个互斥体
let counter = Arc::new(Mutex::new(0));
// 创建多个线程，每个线程递增计数器
let mut handles = vec![];
for _ in 0..5 {
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();
}
// 打印计数器的值
println!("Result: {}", *counter.lock().unwrap());
}
4. 使用 async 和 await 进行异步编程
Rust 还引入了异步编程的支持，通过 async 和 await 关键字，你可以编写异步代码，利用异步运行时执行异步任务。这提供了一种高效地处理大量并发任务的方式。
use tokio::time::Duration;
async fn async_task() {
// 异步任务的实现
tokio::time::sleep(Duration::from_secs(1)).await;
println!("Async task completed!");
}
#[tokio::main]
async fn main() {
// 启动异步任务
tokio::spawn(async_task());
// 主线程的其他工作
println!("Main thread doing other work...");
// 等待异步任务完成
tokio::time::sleep(Duration::from_secs(2)).await;
}
上述例子使用了 tokio 异步运行时，你可以通过在 Cargo.toml 中添加 tokio 依赖来使用。
[dependencies]
tokio = { version = "1", features = ["full"] }
Rust 提供了强大的并发性支持，你可以根据具体需求选择使用线程、消息传递、共享状态或异步编程等不同的手段。
转载请注明出处：http://www.zyzy.cn/article/detail/6778/Rust