Rust 并发编程

醉古意

Rust 提供了多种并发编程的工具，包括线程（threads）、协程（coroutines，通过 async/await 实现）、通道（channels）、互斥锁（mutexes）和原子操作（atomic operations）等。下面是一些简单的 Rust 并发编程代码示例。
示例 1: 使用线程（std::thread）
rust
use std::thread;  
use std::sync::mpsc; // 多生产者单消费者通道  
jlhxwine.com.cn/hhhxxxhxhx
shennongbuluo.cn/hhhxxxhxhx
jsnthl.com.cn/hhhxxxhxhx
gaoerfushebei.com.cn/hhhxxxhxhx
krass.cn/hhhxxxhxhx
gushangcheng-food.cn/hhhxxxhxhx
tjwanhao.com.cn/hhhxxxhxhx
kjoshw.cn/hhhxxxhxhx
daxin989.cn/hhhxxxhxhx
cuiyixuetang.cn/hhhxxxhxhx
jd-sm.cn/hhhxxxhxhx  
fn main() {  
// 创建一个通道  
let (tx, rx) = mpsc::channel();  
// 创建新线程并发送消息  
thread::spawn(move || {  
let value = 42;  
tx.send(value).unwrap(); // 发送值到通道  
});  
// 接收来自通道的消息  
let received = rx.recv().unwrap(); // 接收值  
println!("Received: {}", received);  
}
示例 2: 使用互斥锁（std::sync::Mutex）
rust
use std::sync::Mutex;  
use std::thread;  
fn main() {  
let counter = Mutex::new(0);  
let mut handles = vec![];  
// 创建多个线程并增加计数器  
for _ in 0..10 {  
let counter = counter.clone();  
let handle = thread::spawn(move || {  
let mut num = counter.lock().unwrap(); // 获取锁  
*num += 1;  
});  
handles.push(handle);  
}  
// 等待所有线程完成  
for handle in handles {  
handle.join().unwrap();  
}  
let final_count = *counter.lock().unwrap();  
println!("Final counter value: {}", final_count);  
}
示例 3: 使用 async/await 进行异步编程
rust
use std::io;  
use std::time::Duration;  
use tokio::runtime; // 使用 Tokio 运行时  
#[tokio::main] // 使用 Tokio 的 main 属性  
async fn main() -> Result {  
let task1 = tokio::spawn(async {  
println!("Task 1 is running");  
tokio::time::sleep(Duration::from_secs(2)).await;  
println!("Task 1 is done");  
});  
let task2 = tokio::spawn(async {  
println!("Task 2 is running");  
tokio::time::sleep(Duration::from_secs(1)).await;  
println!("Task 2 is done");  
});  
// 等待所有任务完成  
task1.await?;  
task2.await?;  
Ok(())  
}
请注意，为了使用 tokio::runtime 和相关的 tokio::spawn 以及 tokio::time::sleep，你需要添加 Tokio 依赖到你的 Cargo.toml 文件中：
toml
[dependencies]  
tokio = { version = "1", features = ["full"] }
这些示例展示了 Rust 中几种不同的并发编程方式。线程用于并行执行代码，互斥锁用于保护共享资源免受竞态条件的影响，而 async/await 允许你编写非阻塞的异步代码。每种方式都有其适用的场景，并且 Rust 的并发工具集非常强大，允许开发者根据需求选择最适合的并发策略。

来源：
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！