在Linux中，Rust可以通过多种方式处理网络通信。以下是一些常用的方法和库：

1. 标准库中的std::net

Rust的标准库提供了基本的网络通信功能，包括TCP和UDP。

TCP

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

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    loop {
        match stream.read(&mut buffer) {
            Ok(0) => break,
            Ok(size) => {
                println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));
                stream.write_all(&buffer[..size]).unwrap();
            }
            Err(_) => break,
        }
    }
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                std::thread::spawn(|| handle_client(stream));
            }
            Err(_) => println!("Error: {}", e),
        }
    }
    Ok(())
}

UDP

use std::net::{UdpSocket, SocketAddr};

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:7878")?;
    let mut buf = [0; 1024];

    loop {
        let (amt, src) = socket.recv_from(&mut buf)?;
        println!("Received {} bytes from {}", amt, src);
        socket.send_to(&buf[..amt], &src)?;
    }
}

2. 第三方库tokio

tokio是一个异步运行时，提供了更高级的网络通信功能。

TCP

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:7878").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut buf = [0; 1024];

            // In a loop, read data from the socket and write the data back.
            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("Failed to read from socket: {:?}", e);
                        return;
                    }
                };

                // Write the data back
                if let Err(e) = socket.write_all(&buf[0..n]).await {
                    eprintln!("Failed to write to socket: {:?}", e);
                    return;
                }
            }
        });
    }
}

UDP

use tokio::net::UdpSocket;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let socket = UdpSocket::bind("127.0.0.1:7878").await?;

    let mut buf = [0; 1024];

    loop {
        let (amt, src) = socket.recv_from(&mut buf).await?;
        println!("Received {} bytes from {}", amt, src);

        socket.send_to(&buf[..amt], &src).await?;
    }
}

3. 第三方库async-std

async-std是另一个异步运行时，提供了类似于tokio的功能。

TCP

use async_std::net::{TcpListener, TcpStream};
use async_std::prelude::*;

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;

    loop {
        let (socket, _) = listener.accept().await?;

        async_std::task::spawn(async move {
            let mut buf = [0; 1024];

            loop {
                let n = match socket.read(&mut buf).await {
                    Ok(0) => return,
                    Ok(n) => n,
                    Err(_) => return,
                };

                if let Err(_) = socket.write_all(&buf[..n]).await {
                    return;
                }
            }
        });
    }
}

UDP

use async_std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:7878")?;

    let mut buf = [0; 1024];

    loop {
        let (amt, src) = socket.recv_from(&mut buf).await?;
        println!("Received {} bytes from {}", amt, src);

        socket.send_to(&buf[..amt], &src).await?;
    }
}

总结

• 标准库：适用于简单的同步网络通信。
• tokio：适用于高性能的异步网络通信。
• async-std：提供了类似于tokio的异步网络通信功能，但API风格略有不同。

选择哪种方法取决于你的具体需求和偏好。