io_uring 入门：用 Rust 打造高性能服务器的异步 IO 秘籍
哥们，你有没有遇到过这种情况：高性能服务器明明 CPU 没跑满，内存也够用，但就是慢得要死？
我前阵子就被这事折腾得够呛。后来一查，好家伙，瓶颈居然在 I/O 操作上。想要打造真正的高性能服务器，异步 IO 是绑不开的话题。这让我想起一个生活中的场景——
传统 I/O 就像去银行办业务
想象一下，你去银行办业务。传统的阻塞 I/O 是什么感觉呢？
你取个号，坐那等着。叫到你了，去柜台办业务。办完一个，再回去坐着等下一个叫号。整个过程中，你就干坐着，啥也干不了。这就是传统的同步阻塞 I/O，一个请求处理完才能处理下一个。
后来银行搞了个 “预约+叫号” 系统，这就像是 epoll。你可以同时关注多个业务的进度，哪个好了就去处理哪个。比之前强多了，但还是有个问题——每次有业务要办，你还是得亲自跑一趟柜台（系统调用）。
io_uring 登场：VIP 专属通道
io_uring 是啥玩意呢？这么说吧，就像银行突然给你开了个 VIP 专属通道。
你看啊，它搞了两条传送带放在你和柜台中间：
一条叫 提交队列（SQ），你把要办的事写张单子往上一扔，嗖的一下就滑到柜台去了。另一条叫 完成队列（CQ），办完的单子从那边自动滑回来。
重点来了——你压根不用跑腿了！就往传送带上扔单子，然后该干嘛干嘛，办好的自己就回来了。柜台那边的人（内核）闷头干活，你完全不用管。
这就是 io_uring 的精髓：通过共享内存的环形缓冲区，大幅减少用户态和内核态之间的切换。这种异步 IO 模型是构建高性能服务器的关键技术。
说人话版本的技术原理
好，咱们稍微深入一点，但我保证不整那些让人头大的东西。
传统的做法是这样的：
你的程序 -> 系统调用 -> 内核处理 -> 返回结果 -> 你的程序继续
每次都要 “过一道关卡”，这个过程叫上下文切换，开销可不小。就像你每次去银行都要过安检、登记、排队，哪怕就取个 100 块钱也得走完全套流程。
io_uring 的做法：
你的程序 <--共享内存--> 内核
| |
放入请求 取出请求
| |
取出结果 放入结果
看到没？通过共享内存，很多操作根本不需要系统调用了。内核和你的程序各干各的，通过两个环形缓冲区传递数据。这就是异步IO的魅力，效率杠杠的。
在 Rust 里怎么玩
说到 Rust 和 io_uring，就不得不提几个好用的库。
最原始的玩法：io-uring 库
use io_uring::{opcode, types, IoUring};
use std::fs::File;
use std::os::unix::io::AsRawFd;
fn main() -> std::io::Result<()> {
// 创建一个能容纳 256 个请求的环
let mut ring = IoUring::new(256)?;
let file = File::open("test.txt")?;
let fd = types::Fd(file.as_raw_fd());
// 准备一个读操作
let mut buf = vec![0u8; 1024];
let read_op = opcode::Read::new(fd, buf.as_mut_ptr(), buf.len() as _)
.build()
.user_data(0x42); // 给这个操作打个标记
// 把操作放入提交队列
unsafe {
ring.submission()
.push(&read_op)
.expect("提交队列满了");
}
// 提交并等待完成
ring.submit_and_wait(1)?;
// 从完成队列取结果
let cqe = ring.completion().next().expect("没有完成的操作");
println!("读取完成，返回值: {}", cqe.result());
Ok(())
}
这是最底层的玩法，就像手动挡汽车，控制力最强，但也最累。
更优雅的方式：tokio-uring
use tokio_uring::fs::File;
#[tokio_uring::main]
async fn main() -> std::io::Result<()> {
let file = File::open("test.txt").await?;
let buf = vec![0u8; 1024];
let (result, buf) = file.read_at(buf, 0).await;
let bytes_read = result?;
println!("读了 {} 字节", bytes_read);
Ok(())
}
看着是不是清爽多了？tokio-uring 把 io_uring 封装成了我们熟悉的 async/await 风格，写起来和普通异步代码没啥区别。
性能狂魔的选择：glommio
use glommio::prelude::*;
fn main() {
LocalExecutorBuilder::default()
.spawn(|| async {
let file = glommio::io::DmaFile::open("test.txt")
.await
.expect("打开文件失败");
let buffer = file.read_at(0, 1024).await.expect("读取失败");
println!("读到了 {} 字节", buffer.len());
})
.expect("启动执行器失败")
.join()
.unwrap();
}
glommio 采用 “thread-per-core” 架构，每个 CPU 核心一个线程，配合 io_uring 简直是性能怪兽。适合那些对延迟要求极高的场景，比如数据库、消息队列什么的。
实战：写个简单的 echo 服务器
光说不练假把式，咱们用 tokio-uring 写个 echo 服务器：
use tokio_uring::net::{TcpListener, TcpStream};
async fn handle_client(stream: TcpStream) {
let mut buf = vec![0u8; 1024];
loop {
let (result, b) = stream.read(buf).await;
buf = b;
match result {
Ok(0) => break, // 连接关闭
Ok(n) => {
let (result, b) = stream.write_all(buf[..n].to_vec()).await;
buf = vec![0u8; 1024];
if result.is_err() {
break;
}
}
Err(_) => break,
}
}
}
#[tokio_uring::main]
async fn main() -> std::io::Result<()> {
let listener = TcpListener::bind("127.0.0.1:8080".parse().unwrap())?;
println!("服务器启动，监听 8080 端口");
loop {
let (stream, addr) = listener.accept().await?;
println!("新连接来自: {}", addr);
tokio_uring::spawn(handle_client(stream));
}
}
这个服务器用了 io_uring 处理所有网络 I/O，在高并发场景下性能会比传统 epoll 方案好不少。
什么时候该上 io_uring
跟你说实话，io_uring 虽然猛，但也不是万能药。得看你的场景合不合适。
这几种情况上它准没错：
你要是在写那种几万几十万连接的服务器，上。文件读写特别频繁的，上。对响应速度要求贼高的，比如交易系统啥的，上。前提是你的机器跑的是 Linux 5.1 以上的内核，不然白搭。
这几种情况就算了：
你的代码要跑 Windows 或者 Mac？那别想了，io_uring 是 Linux 的亲儿子，别的系统压根没有。你的程序瓶颈根本不在 I/O 上？那折腾它干嘛，解决不了问题还白费功夫。团队就你一个人懂这玩意？那维护起来也够你喝一壶的。
一些踩坑经验
用 io_uring 这段时间，我踩了不少坑，分享几个：
1. 缓冲区所有权问题
io_uring 是真正的异步，意味着你把缓冲区交给它之后，在操作完成前不能动这块内存。Rust 的所有权系统在这里帮了大忙，但也需要适应这种 “缓冲区借出去又还回来” 的模式。
2. 内核版本很重要
不同内核版本支持的 io_uring 特性不一样。比如网络操作在 5.6 才比较完善，5.7 加入了更多优化。升级前最好查查兼容性。
3. 调试比较麻烦
因为操作是异步提交的，出问题时堆栈信息可能不太直观。建议多加日志，用好 user_data 字段来追踪请求。
小结
io_uring 代表了 Linux 异步 IO 的未来方向。它通过共享内存环形缓冲区的设计，大幅减少了系统调用开销，让我们能榨干硬件的最后一滴性能。对于想要构建高性能服务器的开发者来说，这是必须掌握的技术。
在 Rust 生态里，从底层的 io-uring 库到上层的 tokio-uring、glommio，各种抽象层次的选择都有。Rust 的内存安全特性和零成本抽象，配合 io_uring 的异步 IO 能力，简直是打造高性能服务器的黄金搭档。
下次你的服务器再遇到 I/O 瓶颈，不妨试试 io_uring。说不定就是你一直在找的那把钥匙。
如果这篇文章对你有帮助，欢迎点赞收藏。有问题可以在评论区留言，我会尽量回复。
关注我，后续会继续分享更多 Rust 高性能编程的实战经验。咱们下篇文章见。