标准库的 std::net 提供了相关实现。
TcpListener TcpStream

tcp server

  1. use std::io::{self, Read, Write};
  2. use std::net::{TcpListener, TcpStream};
  3. use std::thread;
  4. use std::time;
  6. fn handle_client(mut stream: TcpStream) -> io::Result<()> {
  7.     // stream buffer
  8.     let mut buf = [0; 512];
  9.     for _ in 0..1000 {
  10.         let bytes_read = stream.read(&mut buf)?;
  11.         if bytes_read == 0 {
  12.             return Ok(());
  13.         }
  15.         stream.write(&buf[..bytes_read])?;
  16.         thread::sleep(time::Duration::from_secs(1));
  17.     }
  19.     Ok(())
  20. }
  21. fn main() -> io::Result<()> {
  22.     let listener = TcpListener::bind("127.0.0.1:8080")?;
  24.     let mut thread_vec: Vec<thread::JoinHandle<()>> = Vec::new();
  26.     for stream in listener.incoming() {
  27.         let stream = stream.expect("stream failed");
  29.         let handle = thread::spawn(move || {
  30.             handle_client(stream).unwrap_or_else(|error| eprintln!("{}", error))
  31.         });
  33.         thread_vec.push(handle);
  34.     }
  36.     for handle in thread_vec {
  37.         handle.join().unwrap();
  38.     }
  40.     Ok(())
  41. }

client

  1. use std::io::{self, prelude::*, BufReader, Write};
  2. use std::net::TcpStream;
  3. use std::str;
  5. fn main() -> io::Result<()> {
  6.     let mut stream = TcpStream::connect("127.0.0.1:8080")?;
  8.     for _ in 0..10 {
  9.         let mut input = String::new();
  10.         io::stdin().read_line(&mut input).expect("Failed to read");
  11.         stream.write(input.as_bytes()).expect("Failed to write");
  13.         let mut reader = BufReader::new(&stream);
  14.         let mut buffer: Vec<u8> = Vec::new();
  15.         reader
  16.             .read_until(b'\n', &mut buffer)
  17.             .expect("Failed to read buffer");
  18.         println!("read from server: {}", str::from_utf8(&buffer).unwrap());
  19.     }
  20.     println!("THE END");
  21.     Ok(())
  22. }