Rust多线程环境下如何将TcpStream绑定到标准IO流？

需求是将标准IO流绑定到TcpStream，已有单线程可行实现代码：

use std::io::{self, BufRead, from_utf8};
use std::net::TcpStream;

fn main() {
    let mut stream = TcpStream::connect("localhost:1912").unwrap();
    let stdin = io::stdin();

    for command in stdin.lock().lines()  {
        {
          let mut cmd = command.unwrap();
          cmd = cmd.add("\n");
          _ = stream.write(cmd.as_bytes()).unwrap();
        }

        {
          let mut resp_data = [0 as u8; 250];
          _ = stream.read(&mut resp_data).unwrap();        
          let text = from_utf8(&resp_data).unwrap();
          print!("{}", text);
        }
    }
}

希望在Rust多线程环境中实现类似功能，但当前尝试的多线程代码因线程间锁竞争无法正常运行：

use std::io::{self, copy};
use std::net::TcpStream;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let stream = Arc::new(Mutex::new(TcpStream::connect("localhost:1912").unwrap()));
    
    let str_clone = stream.clone();
    thread::spawn(move || {
        let mut stdout = io::stdout();
        let mut str = str_clone.lock().unwrap();
        _ = copy(&mut *str, &mut stdout);
    });

    let mut stdin = io::stdin();
    let mut str = stream.lock().unwrap();
    _ = copy(&mut stdin, &mut *str);
}

参考Go语言的实现示例：

package main

import (
    "io"
    "net"
    "os"
)

func main() {
    c, _ := net.Dial("tcp", ":1912")
    go io.Copy(os.Stdout, c)
    io.Copy(c, os.Stdin)
}

作为Rust新手，希望了解该功能的最优实现方式。

你遇到的核心问题是用Arc<Mutex>包裹整个TcpStream导致读写线程互相阻塞——读线程持有锁时写线程无法获取，写线程持有锁时读线程也无法工作。而TcpStream本身支持读写分离，通过split方法可以将其拆分为独立的ReadHalf和WriteHalf，这两个部分可以分别安全地在不同线程中使用，无需互斥锁，这才是符合Rust设计理念的最优方案。

以下是对应的实现代码：

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

fn main() -> io::Result<()> {
    let mut stream = TcpStream::connect("localhost:1912")?;
    // 拆分TcpStream为读、写两个独立的半部分，各自可独立操作
    let (mut read_half, mut write_half) = stream.split();

    // 启动子线程：将TcpStream的读取内容复制到标准输出
    let handle = thread::spawn(move || -> io::Result<()> {
        copy(&mut read_half, &mut io::stdout())?;
        Ok(())
    });

    // 主线程：将标准输入的内容复制到TcpStream
    copy(&mut io::stdin(), &mut write_half)?;

    // 等待子线程完成后退出
    handle.join()??;
    Ok(())
}

方案说明 #

1. 读写分离的优势：
   split方法利用Rust的类型系统保证了ReadHalf和WriteHalf的线程安全性，两者可以同时被不同线程访问，完全避免了锁竞争，性能比Arc<Mutex>方案更优。
2. 错误处理优化：
   示例中使用?和Result类型处理IO错误，替代了原代码中的unwrap()，这是Rust中更健壮的错误处理方式，实际项目中建议保留这种模式。
3. 和Go实现逻辑对齐：
   该方案的逻辑和你给出的Go代码完全一致——一个线程负责从TcpStream读数据到stdout，主线程负责从stdin写数据到TcpStream，语义清晰且符合直觉。

如果后续需要重新合并读写半部分，可以使用TcpStream::unsplit(read_half, write_half)方法，但在当前场景下不需要这一步。

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