1、异步并发控制：Semaphore、Mutex、RwLock的异步版本

为什么需要异步同步原语？

💡在同步编程中，我们使用std::sync::Mutexstd::sync::RwLock和std::sync::Semaphore等同步原语来控制并发访问。这些原语在多线程场景下非常有效。但在异步编程中，它们会导致任务阻塞，影响性能。你可能遇到的痛点是：线程被阻塞导致 CPU 利用率下降，甚至出现“活锁”或“死锁”的现象。

异步同步原语通过 await 暂停任务。而不是阻塞线程，从而提高了 CPU 利用率。Tokio 提供了一系列异步同步原语，如 tokio::sync::Mutextokio::sync::RwLock 和 tokio::sync::Semaphore。

异步 Mutex

痛点： 当多个任务竞争同一个资源时如果使用同步 Mutex。整个线程会被阻塞，导致其它协程无法调度。异步 Mutex 则只会挂起当前协程，让事件循环继续执行其它任务。

use tokio::sync::Mutex;老实说，use std::{sync::Arc};#
async fn main {
// 创建共享计数器
let counter = Arc::new);老实说，let mut handles = vec!，// 创建10个并发任务，每个任务增加计数器
for i in 0..10 {
let counter_clone = counter.clone;let handle = tokio::spawn(async move {
// 获取锁，使用 await 挂起直到锁可用
let mut guard = counter_clone.lock.await;按理说，*guard += 1;println，;// 锁会在 guard 离开作用域时自动释放
});handles.push;话说回来，}
// 等待所有任务完成
for handle in handles {
handle.await.unwrap;}
println，.await);不过，}

异步 RwLock

痛点： 同步 RwLock 会让写操作阻塞所有读操作。造成大量上下文切换，异步 RwLock 可以让多个读者同时访问，而写者仍然独占。

use tokio::{sync::RwLock};use std::{sync::Arc};#
async fn main {
let data = Arc::new);let mut handles = vec!，// 创建5个读任务
for i in 0..5 {
let data_clone = data.clone;let handle = tokio::spawn(async move {
let guard = data_clone.read.await;println，;})，按理说，handles.push;}
// 创建1个写任务
let data_clone = data.clone;let handle = tokio::spawn(async move {
let mut guard = data_clone.write.await;guard.push，话说回来，println!，});handles.push;// 等待所有任务完成
for handle in handles {
handle.await.unwrap;}
}

异步 Semaphore

痛点： 导致线程池饱和。

use tokio::{self as tokio};use std::{sync::{Arc}};use tokio::{
再看sync，:{
Semaphore。},time::{sleep,Duration},};#
async fn main {
// 信号量允许最多3个并发访问
let semaphore = Arc::::new>>::new);let mut handles = vec!，说起来，for i in 0..10 {
let semaphore_clone= semaphore.clone;let handle=tokio::_spawn(async move{
// 请求许可，会挂起直到许可可用
let _permit=semaphore_clone.acquire.await.unwrap;println，;sleep).await;println，;/* _permit 自动释放 */
});handles.push;}
for h in handles { h.await.unwrap;其实，}
}

A、同步原语的性能对比与适用场景概览表格

B、超时与取消的高级用法

多层超时处理示例

痛点： 单一超时可能无法满足复杂业务需求。例如网络请求有总时间限制，同时内部调用也需要细粒度限时。下面演示如何实现多层超时。

取消信号传递与子任务协同取消示例

痛点： 当父任务被取消后如果子任务没有及时响应，也许会继续占用资源或产生副作用。通过 oneshot 通道可以让子任务及时感知取消信号。不过，

优雅取消与资源清理示例

若文件 I/O 未能及时关闭。文件句柄泄露，若错误发生未处理，则程序崩溃。下面演示在 `select!` 中捕获取消信号，并手动关闭文件。

C、常见设计模式实践：生产者-使用者 / 事件驱动 / Actor 模型

生产者 - 使用者模式实现

如果生产者/使用者之间采用共享内存但没有合适同步机制。将出现竞争条件或死锁，mpsc 通道天然保证了消息顺序且无竞争。

事件驱动模式实现

传统回调式代码易造成回调地狱；其实，利用流式 API 可以把事件拆成可组合的数据流，更易维护。不过，

Actor 模型基础实现

传统共享状态模型往往需要细粒度锁；Actor 模型将状态封闭在单独协程内。通过消息传递消除共享数据问题，从而避免死锁和竞态条件。