Rust中使用Arc和Mutex跨线程访问TCP连接报错排查

错误原因 #

你遇到的E0382错误核心是主线程启动监听线程时，move闭包夺走了server的所有权。thread::spawn(move || {})里的move关键字会将整个server实例移动到新线程中，主线程后续的loop再尝试访问server.connected_clients时，server已经不属于主线程，自然触发"使用已移动值"的错误。

Arc与Mutex核心机制 #

Arc（原子引用计数） #

• 专为多线程场景设计的共享所有权工具，通过克隆Arc实例创建指向同一数据的新引用，克隆操作会原子性增加引用计数。
• 只有当所有Arc实例都被销毁时，底层共享数据才会被自动释放，保证线程安全的内存管理。

Mutex（互斥锁） #

• 用于保护共享数据的访问权限，确保同一时间只有一个线程能操作被包裹的数据。
• 调用lock()方法会阻塞当前线程直到获取锁，返回的MutexGuard是智能指针，当它离开作用域时会自动释放锁，无需手动管理锁的生命周期。

修正后的代码 #

use std::io::Read;
use std::net::{TcpListener, TcpStream};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    // 先创建共享的连接列表Arc
    let connected_clients = Arc::new(Mutex::new(Vec::new()));
    let server = Server {
        connected_clients: connected_clients.clone()
    };

    // 克隆Arc传给监听线程，不移动整个server
    let listener_clients = connected_clients.clone();
    thread::spawn(move || {
        let listener = TcpListener::bind("127.0.0.1:25565").unwrap();

        // 处理每个新连接
        for stream in listener.incoming() {
            let stream = Arc::new(Mutex::new(stream.unwrap()));
            let client = Client {
                stream: stream.clone()
            };

            // 使用克隆后的Arc操作连接列表
            let cc = listener_clients.clone();
            cc.lock().unwrap().push(client);

            thread::spawn(move || {
                let mut buffer = [0; 1024];
                loop {
                    // 增加错误处理，避免连接断开时程序崩溃
                    match stream.lock().unwrap().read(&mut buffer) {
                        Ok(0) => break, // 连接已关闭
                        Ok(n) => {
                            let msg = String::from_utf8_lossy(&buffer[..n]).trim();
                            println!("收到消息: {}", msg);
                        }
                        Err(e) => {
                            eprintln!("读取错误: {}", e);
                            break;
                        }
                    }
                }
            });
        }
    });

    // 主线程每10秒打印所有客户端地址
    loop {
        thread::sleep(Duration::from_secs(10));
        let clients = server.connected_clients.lock().unwrap();
        for client in clients.iter() {
            match client.stream.lock().unwrap().peer_addr() {
                Ok(addr) => println!("客户端地址: {:?}", addr),
                Err(e) => eprintln!("获取地址失败: {}", e)
            }
        }
    }
}

#[derive(Debug)]
struct Server {
    connected_clients: Arc<Mutex<Vec<Client>>>,
}

#[derive(Debug)]
struct Client {
    stream: Arc<Mutex<TcpStream>>
}

关键修改点 #

1. 提前克隆connected_clients的Arc传给监听线程，避免移动整个server导致所有权冲突。
2. 给数据读取逻辑增加错误处理，应对连接断开等异常情况，避免程序直接崩溃。
3. 主线程通过server中保存的Arc安全访问连接列表，所有权不再产生冲突。

内容的提问来源于stack exchange，提问作者Austin Hamner