Rust中Unix Domain Sockets跨线程通信失败问题求助

你编写的代码尝试通过Unix Domain Socket实现线程间通信，但客户端连接后无法收到服务器发送的Hello, I'm server消息，核心原因是死锁，具体分析和修复方案如下：

问题根源 #

• read_to_string方法会持续读取数据，直到遇到**EOF（流结束标记）**才会返回
• 服务器写完消息后，未关闭Socket的写方向，而是立刻调用read_to_string等待客户端消息
• 客户端启动后直接调用read_to_string，一直等待服务器关闭流才能返回，导致双方互相阻塞，形成死锁

修复方案 #

方案1：关闭服务器写半区（单向通信后切换） #

服务器在写完消息后，调用shutdown(Shutdown::Write)关闭写方向，让客户端的read_to_string收到EOF并返回，之后客户端再发送消息给服务器。

修改服务器关键代码片段：

// 写完消息后添加写半区关闭逻辑
match socket.shutdown(std::net::Shutdown::Write) {
    Ok(()) => println!("server closed write half"),
    Err(e) => eprintln!("server shutdown failed: {e:?}"),
}

// 继续读取客户端消息
let mut response = String::new();
match socket.read_to_string(&mut response) {
    Ok(length) => println!("server received {} bytes {}", length, response),
    Err(e) => {
        eprintln!("server Couldn't read: {e:?}");
        return;
    },
}

方案2：用换行分隔消息，读取单行数据 #

改用BufReader读取单行数据，不需要关闭流，只要消息末尾带换行符，双方就能交替读写，支持多次双向通信。

修改后的完整代码：

use std::os::unix::net::{UnixListener, UnixStream};
use std::io::{prelude::*, BufReader};
use std::net::Shutdown;

fn server() {
    let listener = match UnixListener::bind("/tmp/rst.sock") {
        Ok(listener) => listener,
        Err(e) => {
            eprintln!("Couldn't bind: {e:?}");
            return;            
        }
    };

    match listener.accept() {
        Ok((mut socket, addr)) => {
            println!("Got a client: {:?} - {:?}", socket, addr);
            
            // 发送带换行的消息
            match socket.write_all(b"Hello, I'm server\n") {
                Ok(()) => println!("server sent"),
                Err(e) => {
                    eprintln!("server failed while writing {e:?}");
                    return;
                },
            }
            
            // 使用BufReader读取单行
            let mut reader = BufReader::new(&socket);
            let mut response = String::new();
            match reader.read_line(&mut response) {
                Ok(length) => println!("server received {} bytes {}", length, response.trim()),
                Err(e) => {
                    eprintln!("server Couldn't read: {e:?}");
                    return;
                },
            }
        },
        Err(e) => println!("accept function failed: {:?}", e),
    }
    // 清理Socket文件，避免下次启动绑定失败
    let _ = std::fs::remove_file("/tmp/rst.sock");
}

fn client() {
    let mut socket = match UnixStream::connect("/tmp/rst.sock") {
        Ok(sock) => sock,
        Err(e) => {
            eprintln!("Couldn't connect: {e:?}");
            return;
        },
    };
    println!("client connected");
    
    // 使用BufReader读取单行
    let mut reader = BufReader::new(&socket);
    let mut response = String::new();
    match reader.read_line(&mut response) {
        Ok(length) => println!("client received {} bytes {}", length, response.trim()),
        Err(e) => {
            eprintln!("client couldn't read: {e:?}");
            return;
        },
    }
    
    // 发送带换行的消息
    match socket.write_all(b"Hello, I'm client\n") {
        Ok(()) => println!("client sent"),
        Err(e) => {
            eprintln!("client couldn't send: {e:?}");
            return;
        },
    }
}

fn main() {
    let server_handle = std::thread::spawn(|| {
        server();
    });
    
    std::thread::sleep(std::time::Duration::from_secs(1));
    
    let client_handle = std::thread::spawn(|| {
        client();
    });
    
    let _ = server_handle.join();
    let _ = client_handle.join();
}

额外说明 #

• 方案1适合单向传递消息后再反向通信的场景，但关闭写半区后服务器无法再向客户端发送消息
• 方案2更灵活，支持多次双向通信，也可以自定义其他分隔符（如特定字节序列）替代换行
• 服务器退出时务必清理Unix Socket文件，否则下次启动会因文件已存在导致绑定失败

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