要说Rust在Linux网络编程中的位置，几句话就能说清楚：内存安全、高性能、并发友好——这三个特性让它成了这个领域里的热门选择。标准库里的std::net提供了基础的TCP、UDP支持，而像tokio、hyper这样的第三方库，则进一步拓展了异步处理和HTTP等高级功能，基本覆盖了从底层到应用层的各类需求。

基础网络编程：TCP/UDP协议

TCP服务器与客户端

Rust标准库的std::net::TcpListener和TcpStream，可以直接用来搭建同步的TCP应用。举个例子，一个简单的TCP回显服务器：它绑定在127.0.0.1:7878上，接受客户端连接后，把收到的数据原封不动地返回去。客户端这边，也是连接后发送消息，再接收服务器的响应。

// TCP服务器（同步）
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    match stream.read(&mut buffer) {
        Ok(size) if size > 0 => {
            println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));
            stream.write_all(&buffer[..size]).unwrap(); // 回显数据
        }
        _ => println!("Client disconnected"),
    }
}

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(e) => eprintln!("Connection error: {}", e),
        }
    }
    Ok(())
}

UDP这边，用std::net::UdpSocket就可以了，它支持无连接的数据传输。下面是一个UDP回显服务器的例子：绑定端口后，进入一个循环，接收数据并直接返回给发送方。

// UDP服务器
use std::io::{self, Write};
use std::net::UdpSocket;

fn main() -> io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:7878");
    let mut buffer = [0; 1024];
    loop {
        let (size, addr) = socket.recv_from(&mut buffer); // 接收数据及客户端地址
        println!("Received: {} from {}", String::from_utf8_lossy(&buffer[..size]), addr);
        socket.send_to(b"Hello, UDP!", &addr); // 回显数据
    }
}

异步网络编程：Tokio生态

一旦遇到高并发的场景，同步模型（比如多线程）的问题就暴露出来了——线程切换的开销会拖慢性能。Rust的tokio库提供了异步I/O运行时，配合async/await语法，能高效地处理大量并发连接。来看一个异步TCP服务器的例子：用tokio::net::TcpListener监听端口，用tokio::spawn为每个连接生成一个异步任务来处理读写。

// 异步TCP服务器（Tokio）
use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let listener = TcpListener::bind("127.0.0.1:7878").await?;
    println!("Server listening on 127.0.0.1:7878");
    loop {
        let (mut socket, _) = listener.accept().await?; // 异步接受连接
        tokio::spawn(async move {
            let mut buffer = [0; 1024];
            loop {
                match socket.read(&mut buffer).await {
                    Ok(0) => break, // 连接关闭
                    Ok(n) => {
                        println!("Received: {}", String::from_utf8_lossy(&buffer[..n]));
                        if let Err(e) = socket.write_all(&buffer[..n]).await {
                            eprintln!("Write error: {}", e);
                            break;
                        }
                    }
                    Err(e) => {
                        eprintln!("Read error: {}", e);
                        break;
                    }
                }
            }
        });
    }
}

高级应用：HTTP服务器与eBPF

HTTP服务器

如果要用Rust快速搭建一个HTTP服务，hyper库（它本身也是基于Tokio的）是个不错的选择。下面这个例子就很简单：监听127.0.0.1:3000，任何请求进来，都返回一句“Hello, Rust!”。

// HTTP服务器（Hyper）
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;

async fn handle_request(_req: Request) -> Result, Infallible> {
    Ok(Response::new(Body::from("Hello, Rust from Hyper")))
}

#[tokio::main]
async fn main() {
    let make_svc = make_service_fn(|_conn| async {
        Ok::<_, Infallible>(service_fn(handle_request))
    });
    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(make_svc);
    if let Err(e) = server.await {
        eprintln!("Server error: {}", e);
    }
}

eBPF网络处理

再往底层走一点，还有Aya这个Rust的eBPF框架。它允许你在Linux内核中安全地运行自定义的网络逻辑，比如流量过滤、网络监控这些。有了Aya，开发者就不用再写C代码了，直接用Rust就能实现内核级的网络处理，性能和安全性都上了一个台阶。

Rust在Linux网络编程中的优势

总结一下，Rust在这方面的优势其实非常清晰：

1. 内存安全：所有权系统和借用检查器，能在编译阶段就捕获空指针、数据竞争这类问题，运行时出错的概率大大降低。
2. 高性能：零成本抽象加上接近C的运行效率，天生适合袋里、网关这种高吞吐量的场景。
3. 并发友好：async/await语法加上tokio这类库，让高并发编程变得简单不少，也避免了传统线程模型带来的额外开销。
4. 生态丰富：从底层的tokio到高层的hyper、actix-web，基本覆盖了全栈需求。

《夸克》非常好用的免费AI浏览器

下载APP查看