Rust 异步并发安全与内存管理最佳实践

3.2 死锁

当多个任务相互等待对方持有的锁时，就会发生死锁。在异步环境中，由于任务切换的不确定性，这种风险依然存在。

use std::sync::Mutex;
use tokio::spawn;

#[tokio::main]
async fn main() {
    let mutex1 = Mutex::new(1);
    let mutex2 = Mutex::new(2);

    let handle1 = spawn(async move {
        let lock1 = mutex1.lock().unwrap();
        println!("Handle1 got lock1");
        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
        // 此时若 Handle2 持有 mutex2 并等待 mutex1，则可能死锁
        let lock2 = mutex2.lock().unwrap();
        println!("Handle1 got lock2");
    });

    let handle2 = spawn(async move {
        let lock2 = mutex2.lock().unwrap();
        println!("Handle2 got lock2");
        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
        let lock1 = mutex1.lock().unwrap();
        println!("Handle2 got lock1");
    });

    handle1.await.unwrap();
    handle2.await.unwrap();
}

3.3 活锁

活锁指任务不断改变状态但无法取得进展。例如两个任务交替获取锁后立即释放，导致彼此都无法完成操作。

use std::sync::Mutex;
use tokio::spawn;

#[tokio::main]
async fn main() {
    let data = Mutex::new(0);
    let handle1 = spawn(async move {
        loop {
            if let Ok(mut lock) = data.try_lock() {
                if *lock < 1000 {
                    *lock += 1;
                    println!("Handle1: {}", *lock);
                } else {
                    break;
                }
            }
            tokio::time::sleep(std::time::Duration::from_millis(1)).await;
        }
    });
    // ... 类似逻辑的 handle2 ...
}

3.4 资源泄漏

任务未正确取消或句柄未关闭会导致资源泄漏。在异步运行时中，任务被丢弃前必须确保清理工作已完成。

use tokio::spawn;
use std::sync::Arc;

struct MyData {
    value: i32,
}

impl Drop for MyData {
    fn drop(&mut self) {
        println!("MyData dropped");
    }
}

#[tokio::main]
async fn main() {
    let data = Arc::new(MyData { value: 42 });
    let handle = spawn(async move {
        println!("Task running");
        tokio::time::sleep(std::time::Duration::from_secs(5)).await;
        println!("Task finished");
    });
    
    handle.abort(); // 撤销任务
    if let Err(e) = handle.await {
        println!("Task aborted: {:?}", e);
    }
}

四、异步并发安全的解决方案

4.1 使用 Arc 与 Mutex

Arc（原子引用计数）配合 Mutex 是实现多线程共享可变状态的推荐方式。Arc 保证内存安全共享，Mutex 保证互斥访问。

use std::sync::{Arc, Mutex};
use tokio::spawn;

#[tokio::main]
async fn main() {
    let data = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();

    for _ in 0..10 {
        let data_clone = Arc::clone(&data);
        handles.push(spawn(async move {
            for _ in 0..1000 {
                let mut lock = data_clone.lock().unwrap();
                *lock += 1;
            }
        }));
    }

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

    println!("Data: {}", data.lock().unwrap()); // 结果确定为 10000
}

4.2 使用 Arc 与 RwLock

当读多写少时，RwLock 允许多个读者同时访问，提高并发性能。

use std::sync::{Arc, RwLock};
use tokio::spawn;

#[tokio::main]
async fn main() {
    let data = Arc::new(RwLock::new(0));
    let mut handles = Vec::new();

    // 写入任务
    for _ in 0..5 {
        let data_clone = Arc::clone(&data);
        handles.push(spawn(async move {
            for _ in 0..1000 {
                let mut lock = data_clone.write().unwrap();
                *lock += 1;
            }
        }));
    }

    // 读取任务
    for _ in 0..5 {
        let data_clone = Arc::clone(&data);
        handles.push(spawn(async move {
            for _ in 0..1000 {
                let lock = data_clone.read().unwrap();
                println!("Data: {}", *lock);
            }
        }));
    }

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

4.3 使用原子类型

对于简单的计数器或标志位，原子类型 (AtomicI32 等) 性能更高，无需锁开销。

use std::sync::atomic::{AtomicI32, Ordering};
use std::sync::Arc;
use tokio::spawn;

#[tokio::main]
async fn main() {
    let data = Arc::new(AtomicI32::new(0));
    let mut handles = Vec::new();

    for _ in 0..10 {
        let data_clone = Arc::clone(&data);
        handles.push(spawn(async move {
            for _ in 0..1000 {
                data_clone.fetch_add(1, Ordering::Relaxed);
            }
        }));
    }

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

    println!("Data: {}", data.load(Ordering::Relaxed));
}

4.4 使用消息传递

避免共享状态的最佳方式是消息传递。通过通道 (mpsc) 在任务间交换数据，天然线程安全。

use tokio::sync::mpsc;
use tokio::spawn;

#[tokio::main]
async fn main() {
    let (sender, mut receiver) = mpsc::channel(10);
    let mut handles = Vec::new();

    for _ in 0..10 {
        let sender_clone = sender.clone();
        handles.push(spawn(async move {
            for i in 0..1000 {
                sender_clone.send(i).await.unwrap();
            }
        }));
    }

    handles.push(spawn(async move {
        let mut sum = 0;
        while let Some(msg) = receiver.recv().await {
            sum += msg;
        }
        println!("Data: {}", sum);
    }));

    drop(sender); // 关闭发送端，通知接收端结束
    for handle in handles {
        handle.await.unwrap();
    }
}

五、异步内存管理的最佳实践

5.1 避免内存泄漏

使用智能指针管理生命周期，确保任务结束时资源自动回收。特别注意 Drop 的实现时机。

use std::sync::Arc;
use tokio::spawn;

struct MyData {
    value: i32,
}

impl Drop for MyData {
    fn drop(&mut self) {
        println!("MyData dropped");
    }
}

#[tokio::main]
async fn main() {
    let data = Arc::new(MyData { value: 42 });
    let handle = spawn(async move {
        println!("Task running");
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        println!("Task finished");
    });
    
    handle.await.unwrap();
    println!("Main task finished");
}

5.2 优化内存分配

频繁分配小对象会增加 GC 压力（虽然 Rust 无 GC，但有堆分配开销）。复用缓冲区可减少分配次数。

use bytes::BytesMut;
use tokio::spawn;

#[tokio::main]
async fn main() {
    let mut handles = Vec::new();
    let pool = BytesMut::with_capacity(1024);

    for _ in 0..10 {
        let mut pool_clone = pool.clone(); // 注意：BytesMut 克隆是浅拷贝还是深拷贝视版本而定，建议用 Arc
        handles.push(spawn(async move {
            for _ in 0..1000 {
                pool_clone.clear();
                pool_clone.extend_from_slice(b"hello world");
            }
        }));
    }

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

5.3 异步任务的内存管理

配置运行时参数以控制线程栈大小和 worker 数量，防止内存溢出。

use tokio::runtime::Builder;
use tokio::time::sleep;
use std::time::Duration;

fn main() {
    let runtime = Builder::new_multi_thread()
        .worker_threads(4)
        .thread_stack_size(2 * 1024 * 1024) // 2MB 栈大小
        .build()
        .unwrap();

    runtime.block_on(async {
        let mut handles = Vec::new();
        for _ in 0..10 {
            handles.push(tokio::spawn(async move {
                println!("Task running");
                sleep(Duration::from_millis(100)).await;
                println!("Task finished");
            }));
        }
        for handle in handles {
            handle.await.unwrap();
        }
    });
}

六、实战项目优化

6.1 公共模块的异步并发安全优化

在 HTTP 客户端中，缓存应使用线程安全的结构。HashMap 需包裹在 Arc<Mutex> 中。

// common/src/http.rs
use reqwest::{Client, Response};
use tokio::sync::Mutex;
use std::sync::Arc;
use std::collections::HashMap;

pub struct HttpClient {
    client: Client,
    cache: Arc<Mutex<HashMap<String, String>>>,
}

impl HttpClient {
    pub fn new() -> Self {
        HttpClient {
            client: Client::new(),
            cache: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    pub async fn get<T: serde::de::DeserializeOwned>(&self, url: &str) -> Result<T, AppError> {
        let mut cache = self.cache.lock().await;
        if let Some(cached) = cache.get(url) {
            return Ok(serde_json::from_str(cached)?);
        }
        let response = self.client.get(url).send().await?;
        let body = response.text().await?;
        cache.insert(url.to_string(), body.clone());
        Ok(serde_json::from_str(&body)?)
    }
}

6.2 数据库连接的内存管理优化

数据库连接池本身已处理了并发安全，但需注意配置合理的最大连接数。

// common/src/db.rs
use sqlx::PgPool;

pub async fn create_pool(config: DbConfig) -> Result<PgPool, AppError> {
    let pool = PgPool::connect_with(
        config.url.parse().unwrap()
    ).await?;
    Ok(pool)
}

6.3 Redis 连接的并发安全优化

Redis 客户端通常支持线程安全共享，使用 Arc 包装即可。

// common/src/redis.rs
use redis::Client;
use std::sync::Arc;

pub struct RedisClient {
    client: Arc<Client>,
}

impl RedisClient {
    pub async fn new(url: &str) -> Result<Self, AppError> {
        let client = Arc::new(Client::open(url.parse().unwrap())?);
        Ok(RedisClient { client })
    }

    pub async fn get_connection(&self) -> Result<redis::Connection, AppError> {
        Ok(self.client.get_connection()?)
    }
}

6.4 任务系统的内存管理优化

使用信号量 (Semaphore) 限制并发度，防止资源耗尽。

// user-sync-service/src/sync.rs
use tokio::sync::Semaphore;
use std::sync::Arc;

async fn sync_users(config: &AppConfig) -> Result<(), AppError> {
    let pool = create_pool(config.db.clone()).await?;
    let redis_client = create_client(config.redis.clone()).await?;
    let semaphore = Arc::new(Semaphore::new(10)); // 限制并发度
    let mut handles = Vec::new();

    for third_party_user in users {
        let permit = semaphore.clone().acquire_owned().await.unwrap();
        let pool_clone = pool.clone();
        let redis_client_clone = redis_client.clone();
        
        handles.push(tokio::spawn(async move {
            let result = process_user(third_party_user, &pool_clone, &redis_client_clone).await;
            drop(permit); // 释放许可
            result
        }));
    }

    for handle in handles {
        handle.await.unwrap()?;
    }
    Ok(())
}

七、总结

Rust 异步开发的核心在于平衡性能与安全。通过理解所有权模型，结合 Arc、Mutex、原子类型及消息传递机制，可以有效规避数据竞争、死锁和资源泄漏。在实战中，合理设计共享状态、优化内存分配及配置运行时参数，是构建高可用系统的关键。希望本文的实践建议能帮助你在项目中落地更稳健的并发架构。