Rust vs C++ epoll 服务器：从内存安全到并发技术优化

引言

在 Linux 网络编程领域，epoll 作为 I/O 多路复用的 "性能王者"，始终是高并发服务的核心技术选型。无论是 Nginx、Redis 这类高性能中间件，还是高并发 Web 服务器，都离不开 epoll 的高效支撑。本文将在 保留 C++ 实现精髓的基础上，展示如何用 Rust 实现同等功能的 epoll 服务器，并深入对比两者在 内存安全、错误处理、并发安全、资源管理 等维度的差异，揭示 Rust 如何在保持性能的同时提供更强的安全保证。Rust通过了更多优秀的处理方式，这样是为什么Rust今年来收到广泛称赞的原因😀。

在一定的学习基础上面，了解什么是epoll模型？

epoll 的原理与工作流程

本节会以示例和图表来讲解 epoll 的原理和工作流程。

创建 epoll 对象

如下图所示，当某个线程调用 epoll_create 方法时，内核会创建一个 eventpoll 对象（也就是程序中 epfd 所代表的对象）。eventpoll 对象也是文件系统中的一员，和 socket 一样，它也会有等待队列。

内核创建 eventpoll 对象

创建一个代表该 epoll 的 eventpoll 对象是必须的，因为内核要维护“就绪列表”等数据，“就绪列表”可以作为 eventpoll 的成员。

维护监视列表

创建 epoll 对象后，可以用 epoll_ctl 添加或删除所要监听的 socket。以添加 socket 为例，如下图，如果通过 epoll_ctl 添加 sock1、sock2 和 sock3 的监视，内核会将 eventpoll 添加到这三个 socket 的等待队列中。

添加所要监听的 socket

当 socket 收到数据后，中断程序会操作 eventpoll 对象，而不是直接操作线程。

接收数据

当 socket 收到数据后，中断程序会给 eventpoll 的“就绪列表”添加 socket 引用。如下图展示的是 sock2 和 sock3 收到数据后，中断程序让 rdlist 引用这两个 socket。

给就绪列表添加引用

eventpoll 对象相当于 socket 和线程之间的中介，socket 的数据接收并不直接影响线程，而是通过改变 eventpoll 的就绪列表来改变线程状态。

当程序执行到 epoll_wait 时，如果 rdlist 已经引用了 socket，那么 epoll_wait 直接返回，如果 rdlist 为空，阻塞线程。

阻塞和唤醒线程

假设计算机中正在运行线程 A 和线程 B，在某时刻线程 A 运行到了 epoll_wait 语句。如下图所示，内核会将线程 A 放入 eventpoll 的等待队列中，阻塞线程。

epoll_wait 阻塞线程

当 socket 接收到数据，中断程序一方面修改 rdlist，另一方面唤醒 eventpoll 等待队列中的线程，线程 A 再次进入运行状态（如下图）。也因为 rdlist 的存在，线程 A 可以知道哪些 socket 发生了变化。

epoll 唤醒线程
 

接下来对比C++和Rust实现的差别

一、epoll 核心函数：C++ 与 Rust 的实现对比

1.1 C++ 版本回顾

C++ 通过系统调用直接操作 epoll，代码如下：

// 创建 epoll 实例
int epfd = epoll_create1(0);

// 添加事件
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = listen_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

// 等待事件
struct epoll_event events[MAX_EVENTS];
int n = epoll_wait(epfd, events, MAX_EVENTS, timeout);

潜在风险点：

• 手动管理 epfd 生命周期，忘记 close() 导致资源泄漏

• epoll_event 结构体的 data 字段是联合体，类型不安全

• 错误处理依赖返回值和全局 errno，容易被忽略

• 无编译期保证线程安全性

1.2 Rust 版本：类型安全的封装

Rust 通过 nix crate 提供类型安全的 epoll 封装：

use nix::sys::epoll::{epoll_create1, epoll_ctl, epoll_wait};
use nix::sys::epoll::{EpollCreateFlags, EpollEvent, EpollFlags, EpollOp};
use std::os::unix::io::RawFd;

pub struct Epoller {
epfd: RawFd,
}

impl Epoller {
pub fn new() -> Result<Self, nix::Error> {
let epfd = epoll_create1(EpollCreateFlags::EPOLL_CLOEXEC)?;
println!("Epoll instance created, fd: {}", epfd);
Ok(Self { epfd })
}

pub fn add_event(&self, fd: RawFd, events: EpollFlags) -> Result<(), nix::Error> {
let mut event = EpollEvent::new(events, fd as u64);
epoll_ctl(self.epfd, EpollOp::EpollCtlAdd, fd, Some(&mut event))
}

pub fn modify_event(&self, fd: RawFd, events: EpollFlags) -> Result<(), nix::Error> {
let mut event = EpollEvent::new(events, fd as u64);
epoll_ctl(self.epfd, EpollOp::EpollCtlMod, fd, Some(&mut event))
}

pub fn delete_event(&self, fd: RawFd) -> Result<(), nix::Error> {
epoll_ctl(self.epfd, EpollOp::EpollCtlDel, fd, None)
}

pub fn wait_events(&self, events: &mut [EpollEvent], timeout: isize)
-> Result<usize, nix::Error> {
epoll_wait(self.epfd, events, timeout)
}
}

// RAII 自动资源管理：Drop trait 自动关闭 epfd
impl Drop for Epoller {
fn drop(&mut self) {
unsafe { libc::close(self.epfd); }
println!("Epoll instance closed, fd: {}", self.epfd);
}
}

🎯 Rust 优势对比：

二、Socket 封装：零成本抽象 vs 手动管理

2.1 C++ 版本

class Socket {
private:
int _sockfd;
public:
Socket() : _sockfd(-1) {}
~Socket() { Close(); }

void Create() {
_sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (_sockfd < 0) {
perror("socket create error");
exit(SOCKET_ERR);
}
// 设置端口复用
int opt = 1;
setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
}

void Bind(uint16_t port) {
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = INADDR_ANY;

if (bind(_sockfd, (struct sockaddr*)&local, sizeof(local)) < 0) {
perror("bind error");
exit(BIND_ERR);
}
}

void Close() {
if (_sockfd > 0) {
close(_sockfd);
_sockfd = -1;
}
}
};

风险点：

• 异常安全问题：构造函数中 exit() 直接终止程序

• 拷贝构造未删除，可能双重 close()

• 手动 memset 初始化，易出错

• 无生命周期保证，fd 可能悬垂

2.2 Rust 版本：所有权保证安全

use std::net::{TcpListener, TcpStream, SocketAddr};
use std::io::{self, Read, Write};
use std::os::unix::io::{AsRawFd, RawFd};

pub struct Socket {
listener: TcpListener,
}

impl Socket {
pub fn new(port: u16) -> io::Result<Self> {
let addr = SocketAddr::from(([0, 0, 0, 0], port));
let listener = TcpListener::bind(addr)?;

// 设置端口复用
listener.set_nonblocking(true)?;

println!("Server listening on 0.0.0.0:{}", port);
Ok(Self { listener })
}

pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
self.listener.accept()
}

pub fn as_raw_fd(&self) -> RawFd {
self.listener.as_raw_fd()
}
}

// 自动实现 Drop，无需手动 close

🚀 Rust 核心优势：

三、完整服务器实现：架构级对比

3.1 C++ 版本核心逻辑

class EpollServer {
private:
std::unique_ptr<Socket> _listen_sock;
std::unique_ptr<Epoller> _epoller;

public:
void Init() {
_listen_sock->Create();
_listen_sock->Bind(_port);
_listen_sock->Listen();
_epoller->UpdateEvent(EPOLL_CTL_ADD, _listen_sock->GetFd(), EPOLLIN);
}

void Start() {
struct epoll_event events[MAX_EVENTS];
while (true) {
int n = _epoller->WaitEvents(events, MAX_EVENTS);
for (int i = 0; i < n; ++i) {
int fd = events[i].data.fd;
if (fd == _listen_sock->GetFd()) {
HandleNewConnection();
} else {
HandleClientData(fd);
}
}
}
}
};

3.2 Rust 完整实现

use nix::sys::epoll::{EpollEvent, EpollFlags};
use std::collections::HashMap;
use std::io::{self, Read, Write};
use std::os::unix::io::{AsRawFd, RawFd};

const MAX_EVENTS: usize = 64;
const DEFAULT_PORT: u16 = 8877;

pub struct EpollServer {
socket: Socket,
epoller: Epoller,
// 使用 HashMap 管理客户端连接（安全的所有权管理）
clients: HashMap<RawFd, TcpStream>,
}

impl EpollServer {
pub fn new(port: u16) -> io::Result<Self> {
let socket = Socket::new(port)?;
let epoller = Epoller::new()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

// 添加监听 socket 到 epoll
epoller.add_event(socket.as_raw_fd(), EpollFlags::EPOLLIN)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

Ok(Self {
socket,
epoller,
clients: HashMap::new(),
})
}

fn handle_new_connection(&mut self) -> io::Result<()> {
match self.socket.accept() {
Ok((mut stream, addr)) => {
println!("New connection: {}, fd: {}", addr, stream.as_raw_fd());

// 设置非阻塞
stream.set_nonblocking(true)?;

let fd = stream.as_raw_fd();
// 添加到 epoll 监控
self.epoller.add_event(fd, EpollFlags::EPOLLIN)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

// 存储连接（所有权转移到 HashMap）
self.clients.insert(fd, stream);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
// 非阻塞模式下的正常情况
}
Err(e) => return Err(e),
}
Ok(())
}

fn handle_client_data(&mut self, fd: RawFd) -> io::Result<()> {
// 从 HashMap 中移除（获取所有权）
if let Some(mut stream) = self.clients.remove(&fd) {
let mut buf = [0u8; 1024];

match stream.read(&mut buf) {
Ok(0) => {
// 客户端关闭连接
println!("Client closed: fd {}", fd);
self.epoller.delete_event(fd).ok();
}
Ok(n) => {
// 回显数据
let received = String::from_utf8_lossy(&buf[..n]);
println!("Received from fd {}: {}", fd, received.trim());

let echo_msg = format!("Server echo: {}", received);
stream.write_all(echo_msg.as_bytes())?;

// 重新放回 HashMap（归还所有权）
self.clients.insert(fd, stream);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
// 非阻塞模式下的正常情况
self.clients.insert(fd, stream);
}
Err(e) => {
eprintln!("Read error from fd {}: {}", fd, e);
self.epoller.delete_event(fd).ok();
}
}
}
Ok(())
}

pub fn start(&mut self) -> io::Result<()> {
let mut events = vec![EpollEvent::empty(); MAX_EVENTS];
let listen_fd = self.socket.as_raw_fd();

println!("Server started, entering event loop…");

loop {
match self.epoller.wait_events(&mut events, 3000) {
Ok(n) => {
for i in 0..n {
let fd = events[i].data() as RawFd;

if fd == listen_fd {
// 新连接
self.handle_new_connection()?;
} else {
// 客户端数据
self.handle_client_data(fd)?;
}
}
}
Err(nix::errno::Errno::EINTR) => {
// 被信号中断，继续循环
continue;
}
Err(e) => {
eprintln!("epoll_wait error: {}", e);
return Err(io::Error::new(io::ErrorKind::Other, e));
}
}
}
}
}

3.3 主程序入口

// main.rs
mod epoller;
mod socket;
mod server;

use server::EpollServer;

fn main() -> std::io::Result<()> {
let mut server = EpollServer::new(8877)?;
server.start()
}

3.4 Cargo.toml 依赖配置

[package]
name = "rust-epoll-server"
version = "0.1.0"
edition = "2021"

[dependencies]
nix = { version = "0.27", features = ["net", "socket"] }

四、深度对比：Rust 的系统性优势

4.1 内存安全：编译期消除整类 Bug

C++ 的常见陷阱

// ❌ 悬垂指针
TcpStream* get_client(int fd) {
TcpStream stream = clients[fd]; // 拷贝
return &stream; // 返回局部变量地址！
}

// ❌ 双重释放
Socket* sock1 = new Socket();
Socket* sock2 = sock1; // 浅拷贝
delete sock1;
delete sock2; // 崩溃！

// ❌ 迭代器失效
for (auto& [fd, stream] : clients) {
if (should_close(fd)) {
clients.erase(fd); // 迭代器失效！未定义行为
}
}

Rust 的编译期保证

// ✅ 编译器阻止悬垂指针
fn get_client(fd: RawFd) -> &TcpStream {
let stream = clients.get(&fd);
stream // ❌ 编译错误：返回引用的生命周期不足
}

// ✅ 所有权系统防止双重释放
let sock1 = Socket::new(8080)?;
let sock2 = sock1; // 所有权转移
// sock1.accept(); // ❌ 编译错误：sock1 已被移动

// ✅ 借用检查防止迭代器失效
for (fd, stream) in &mut clients {
if should_close(*fd) {
clients.remove(fd); // ❌ 编译错误：不能在借用时修改
}
}

// ✅ 正确写法：使用 retain
clients.retain(|fd, _| !should_close(*fd));

4.2 错误处理：从运行时崩溃到编译期强制

C++ 的错误处理痛点

// ❌ 容易忽略错误
int fd = socket(AF_INET, SOCK_STREAM, 0);
// 忘记检查 fd < 0，后续使用导致未定义行为

// ❌ 异常安全问题
void process_client(int fd) {
char* buf = new char[1024];
int n = read(fd, buf, 1024); // 如果抛异常，buf 泄漏
// …
delete[] buf;
}

// ❌ 错误码混乱
if (epoll_wait(…) < 0) {
if (errno == EINTR) { /* 处理 */ }
else { /* 其他错误 */ }
}

Rust 的类型化错误处理

// ✅ Result 强制处理错误
let stream = TcpStream::connect("127.0.0.1:8080")?; // 必须处理

// ✅ RAII 保证异常安全
fn process_client(fd: RawFd) -> io::Result<()> {
let buf = vec![0u8; 1024]; // 自动析构，无泄漏风险
stream.read(&mut buf)?;
// 即使提前返回，buf 也会自动释放
Ok(())
}

// ✅ 枚举类型区分错误
match stream.read(&mut buf) {
Ok(n) => println!("Read {} bytes", n),
Err(e) if e.kind() == io::ErrorKind::WouldBlock => { /* 非阻塞 */ }
Err(e) if e.kind() == io::ErrorKind::Interrupted => { /* 被中断 */ }
Err(e) => eprintln!("Fatal error: {}", e),
}

4.3 并发安全：从加锁噩梦到类型系统保证

C++ 的并发陷阱

// ❌ 数据竞争（未定义行为）
std::map<int, TcpStream> clients; // 全局共享

void thread1() {
clients[100] = TcpStream(…); // 写入
}

void thread2() {
auto it = clients.find(100); // 读取，可能崩溃！
}

// ❌ 死锁
std::mutex mtx1, mtx2;
void thread_a() {
std::lock_guard<std::mutex> lock1(mtx1);
std::lock_guard<std::mutex> lock2(mtx2); // 死锁！
}
void thread_b() {
std::lock_guard<std::mutex> lock2(mtx2);
std::lock_guard<std::mutex> lock1(mtx1);
}

Rust 的编译期并发安全

use std::sync::{Arc, Mutex};
use std::thread;

// ✅ 编译期防止数据竞争
let clients = Arc::new(Mutex::new(HashMap::new()));

let clients_clone = Arc::clone(&clients);
thread::spawn(move || {
let mut map = clients_clone.lock().unwrap();
map.insert(100, stream); // 自动加锁
}); // 离开作用域自动解锁

// ❌ 编译错误：无法在不加锁的情况下访问共享数据
// clients.get(&100); // 编译失败：Mutex 强制加锁

// ✅ 编译期防止死锁（通过 Send/Sync trait）
// Arc<Mutex<T>> 只有在 T 实现了 Send 时才能跨线程
// 编译器自动验证类型安全

4.4 性能对比：零成本抽象的实践

基准测试结果（模拟 10000 并发连接）

关键发现：

• Rust 的零成本抽象在运行时无额外开销

• 所有权系统优化了内存布局（无隐式拷贝）

• 编译时间较长，但通过增量编译可缓解

五、实战扩展：Rust 的高级特性

5.1 边缘触发（ET）模式实现

impl EpollServer {
pub fn new_with_et(port: u16) -> io::Result<Self> {
let socket = Socket::new(port)?;
let epoller = Epoller::new()?;

// 边缘触发 + 非阻塞 I/O
epoller.add_event(
socket.as_raw_fd(),
EpollFlags::EPOLLIN | EpollFlags::EPOLLET // ET 模式
)?;

Ok(Self { socket, epoller, clients: HashMap::new() })
}

fn handle_client_data_et(&mut self, fd: RawFd) -> io::Result<()> {
if let Some(mut stream) = self.clients.remove(&fd) {
let mut buf = vec![0u8; 4096];

// ET 模式：必须循环读取直到 WouldBlock
loop {
match stream.read(&mut buf) {
Ok(0) => {
println!("Client closed: fd {}", fd);
self.epoller.delete_event(fd).ok();
return Ok(());
}
Ok(n) => {
// 处理数据
let data = &buf[..n];
// … 业务逻辑
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
// 读取完毕，退出循环
self.clients.insert(fd, stream);
break;
}
Err(e) => {
eprintln!("Read error: {}", e);
self.epoller.delete_event(fd).ok();
return Err(e);
}
}
}
}
Ok(())
}
}

5.2 结合 Tokio 实现异步版本

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

#[tokio::main]
async fn main() -> io::Result<()> {
let listener = TcpListener::bind("0.0.0.0:8877").await?;
println!("Async server listening on port 8877");

loop {
let (stream, addr) = listener.accept().await?;
println!("New connection: {}", addr);

// 每个连接一个异步任务（底层仍用 epoll）
tokio::spawn(async move {
if let Err(e) = handle_client(stream).await {
eprintln!("Client error: {}", e);
}
});
}
}

async fn handle_client(mut stream: TcpStream) -> io::Result<()> {
let mut buf = [0u8; 1024];

loop {
let n = stream.read(&mut buf).await?;
if n == 0 {
return Ok(());
}

let echo_msg = format!("Server echo: {}",
String::from_utf8_lossy(&buf[..n]));
stream.write_all(echo_msg.as_bytes()).await?;
}
}

异步版本的优势：

• 代码更简洁（无需手动管理状态机）

• 自动处理 ET 模式的复杂性

• 更好的可组合性（可轻松添加超时、限流等）

六、总结：Rust 重新定义系统编程的安全边界

6.1 核心优势总结

6.2 何时选择 Rust？

✅ 强烈推荐 Rust 的场景：

• 安全关键系统（金融、医疗、自动驾驶）

• 高并发网络服务（无 GC 延迟）

• 需要长期维护的大型项目

• 团队成员经验参差不齐

⚠️ C++ 仍有优势的场景：

• 已有大量 C++ 代码库需要集成

• 需要极其成熟的第三方库生态

• 团队已深度掌握 C++ 最佳实践

• 编译时间极度敏感的场景

6.3 学习路径建议

6.4 最终思考

Rust 并非要 "取代" C++，而是在系统编程领域提供了一种新的可能性：

• 不再需要在 "安全" 和 "性能" 间妥协

• 通过类型系统将运行时错误提前到编译期

• 让并发编程从 "专家级技能" 变为 "日常开发"

正如 C++ 之父 Bjarne Stroustrup 所言："C++ 让你可以把脚打烂，Rust 则不让你扣动扳机。" 在对安全性要求日益提高的今天，Rust 代表了系统编程的未来方向。