Sockets 设置套接字上的读取超时

我在Rust中有一个TCP echo服务器，它可以随机丢弃消息。我正在尝试在客户端套接字上设置读取超时

客户端

use std::net::TcpStream;
use std::str;
use std::io::{self, BufRead, BufReader, Write};
use std::time::Duration;
use std::net::SocketAddr;

fn main() {
    let remote: SocketAddr = "127.0.0.1:8888".parse().unwrap();
    let mut stream = TcpStream::connect_timeout(&remote, Duration::from_secs(1)).expect("Could not connect to server");
    stream.set_read_timeout(Some(Duration::from_millis(1))).expect("Could not set a read timeout");
    loop {
        let mut input = String::new();
        let mut buffer: Vec<u8> = Vec::new();
        io::stdin().read_line(&mut input).expect("Failed to read from stdin");
        stream.write(input.as_bytes()).expect("Failed to write to server");

        let mut reader = BufReader::new(&stream);

        reader.read_until(b'\n', &mut buffer).expect("Could not read into buffer");
        print!("{}", str::from_utf8(&buffer).expect("Could not write buffer as string"));
    }
}

set\u read\u timeout

调用似乎没有做任何事情；在服务器删除消息和中止连接之间，客户机仍然会等待几秒钟

这不是我运行你的代码的经验。事实上，当我在

read\u until

调用之后直接添加

eprintln

时，当服务器决定断开连接时，它几乎立即打印出来。事实上，问题不在于阅读，而在于写作，正如您从错误消息中所看到的：

线程“main”在“处惊慌失措，无法写入服务器：

我猜你不是在“等待几秒钟”，而是多次按Enter键（在“bar”和紧急消息之间的空行也表明了这一点）。您的读取超时工作正常-问题在于：

---

通过退出循环，您将完全关闭套接字。您可以在客户端检测到这一点，也可以继续服务器循环而不是退出它。

FYI，

flip

可以是

fn flip（）->bool{rand:：thread_rng（）.gen（）}

extern crate rand;

use std::net::{TcpListener, TcpStream};
use std::thread;
use rand::{thread_rng, Rng};

use std::io::{Error, Read, Write};

fn flip() -> bool {
    let choices = [true, false];
    let mut rng = thread_rng();
    *rng.choose(&choices).unwrap()
}

fn handle_client(mut stream: TcpStream) -> Result<(), Error> {
    let mut buf = [0; 512];
    loop {
        let bytes_read = stream.read(&mut buf)?;
        if bytes_read == 0 {
            return Ok(());
        }
        if flip() {
            return Ok(());
        }
        stream.write(&buf[..bytes_read])?;
    }
}

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8888").expect("Could not bind");
    for stream in listener.incoming() {
        match stream {
            Err(e) => eprintln!("failed: {}", e),
            Ok(stream) => {
                thread::spawn(move || {
                    handle_client(stream).unwrap_or_else(|error| eprintln!("{:?}", error));
                });
            }
        }
    }
}

if flip() {
    return Ok(());
}