Rust多线程TCP通信程序推荐实现模型咨询

1. 直接使用Arc<Mutex<TcpStream>>（无死锁风险） #

只要避免嵌套锁定和长时间持有锁，这种方案不会引发死锁。死锁的核心是两个线程互相等待对方释放锁，而如果读线程仅在读取数据时短暂锁定、读完立即释放，主线程仅在发送/关闭操作时短暂锁定、完成后立即释放，两者不会形成循环等待。

示例代码：

use std::sync::{Arc, Mutex};
use std::net::TcpStream;
use std::thread;
use std::io::{Read, Write};

fn main() {
    let stream = TcpStream::connect("127.0.0.1:8080").unwrap();
    let shared_stream = Arc::new(Mutex::new(stream));

    // 读取线程
    let read_stream = Arc::clone(&shared_stream);
    thread::spawn(move || {
        let mut buf = [0; 1024];
        loop {
            let mut stream = read_stream.lock().unwrap();
            match stream.read(&mut buf) {
                Ok(0) => break, // 连接关闭
                Ok(n) => println!("收到数据: {}", String::from_utf8_lossy(&buf[..n])),
                Err(e) => {
                    eprintln!("读取错误: {}", e);
                    break;
                }
            }
            // 锁在此处自动释放
        }
    });

    // 主线程发送数据/关闭连接
    let mut input = String::new();
    loop {
        std::io::stdin().read_line(&mut input).unwrap();
        if input.trim() == "exit" {
            let mut stream = shared_stream.lock().unwrap();
            stream.shutdown(std::net::Shutdown::Both).unwrap();
            break;
        }
        let mut stream = shared_stream.lock().unwrap();
        stream.write_all(input.as_bytes()).unwrap();
        input.clear();
    }
}

2. 拆分TcpStream为读写两端（更优方案） #

Rust标准库的TcpStream提供了split()方法，可将其拆分为ReadHalf和WriteHalf。这两个类型都实现了Send trait，能安全地分别传递给不同线程，无需使用锁，从根源上避免了锁相关问题。

示例代码：

use std::net::TcpStream;
use std::thread;
use std::io::{Read, Write};

fn main() {
    let stream = TcpStream::connect("127.0.0.1:8080").unwrap();
    let (mut read_half, mut write_half) = stream.split();

    // 读取线程
    thread::spawn(move || {
        let mut buf = [0; 1024];
        loop {
            match read_half.read(&mut buf) {
                Ok(0) => {
                    println!("连接已关闭");
                    break;
                }
                Ok(n) => println!("收到数据: {}", String::from_utf8_lossy(&buf[..n])),
                Err(e) => {
                    eprintln!("读取错误: {}", e);
                    break;
                }
            }
        }
    });

    // 主线程发送数据/关闭连接
    let mut input = String::new();
    loop {
        std::io::stdin().read_line(&mut input).unwrap();
        if input.trim() == "exit" {
            write_half.shutdown(std::net::Shutdown::Write).unwrap();
            break;
        }
        write_half.write_all(input.as_bytes()).unwrap();
        input.clear();
    }
}

这个方案无需锁，代码更简洁，且线程间无共享可变状态，是简单读写场景下的首选。

3. 消息队列方案（适合复杂场景） #

如果业务逻辑需要处理更多类型的指令（如除读写外的其他操作），可以采用消息队列模式：主线程将发送数据、关闭连接等指令封装为消息发送到队列，工作线程轮询队列处理指令，同时负责读取数据。这种方案代码量会增加，但逻辑更清晰，适合复杂业务场景。

核心思路：

• 定义枚举类型表示消息：enum Message { Send(Vec<u8>), Close }
• 主线程持有Sender<Message>，工作线程持有Receiver<Message>和TcpStream
• 工作线程通过select!（需依赖crossbeam-channel库）同时监听消息队列和TcpStream的可读事件（需将TcpStream设为非阻塞模式）

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