在C++程序开发中，文件IO操作是常见的功能需求，传统的同步读写方式会在操作执行期间阻塞当前线程，当处理大文件或者高并发场景时，会严重影响程序的响应速度和整体性能。异步文件读写可以让IO操作在后台执行，主线程可以继续处理其他逻辑，是优化程序性能的重要手段。
aio_read基础使用
aio_read是POSIX标准提供的异步读文件接口，属于异步IO（AIO）系列函数的一部分，它可以在不阻塞调用线程的情况下发起文件读取请求，操作完成后会通过信号或者回调通知应用程序。
aio_read核心结构体
使用aio_read需要先定义aiocb结构体，该结构体用来配置异步读操作的各项参数，结构体的主要成员如下：
- aio_fildes：要读取的文件描述符
- aio_buf：用来存储读取数据的缓冲区指针
- aio_nbytes：期望读取的字节数
- aio_offset：读取的起始偏移量
- aio_sigevent：操作完成后的通知方式配置
基础使用示例
下面是一个简单的aio_read使用示例，实现异步读取文件内容：
#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <aio.h>
#include <string.h>
#include <errno.h>
int main() {
// 打开要读取的文件
int fd = open("test.txt", O_RDONLY);
if (fd == -1) {
std::cerr << "打开文件失败，错误码：" << errno << std::endl;
return 1;
}
// 定义aiocb结构体并初始化
struct aiocb async_read_cb;
memset(&async_read_cb, 0, sizeof(struct aiocb));
char buffer[1024];
async_read_cb.aio_fildes = fd;
async_read_cb.aio_buf = buffer;
async_read_cb.aio_nbytes = sizeof(buffer) - 1; // 留一个位置给字符串结束符
async_read_cb.aio_offset = 0;
// 发起异步读请求
if (aio_read(&async_read_cb) == -1) {
std::cerr << "发起异步读请求失败，错误码：" << errno << std::endl;
close(fd);
return 1;
}
// 轮询检查操作是否完成，实际项目中可以用信号或者回调优化
while (aio_error(&async_read_cb) == EINPROGRESS) {
// 可以在这里处理其他逻辑
}
// 获取操作结果
ssize_t read_bytes = aio_return(&async_read_cb);
if (read_bytes > 0) {
buffer[read_bytes] = ' ';
std::cout << "读取到的内容：" << buffer << std::endl;
} else {
std::cerr << "读取文件失败，错误码：" << errno << std::endl;
}
close(fd);
return 0;
}
Future模式核心思想
Future模式是一种常用的异步编程设计模式，它的核心思想是当发起一个异步任务时，立即返回一个Future对象，这个对象相当于一个占位符，后续可以通过这个对象获取异步任务的最终执行结果。如果任务还没有完成，调用获取结果的方法会阻塞直到任务完成，这样既不会阻塞主线程发起任务，又可以在需要结果的时候再等待获取。
Future模式通常包含几个核心角色：
- Future接口：定义获取异步结果的方法
- Future实现类：保存任务执行状态，提供获取结果的方法，内部会处理任务完成后的结果存储和等待逻辑
- 任务提交者：提交异步任务，返回Future对象
- 任务执行者：执行具体的异步任务，完成后将结果设置到Future对象中
aio_read与Future模式结合实现
原生的aio_read需要手动轮询检查状态或者处理信号，使用起来不够方便，结合Future模式可以封装出更易用的异步文件读写接口，让调用方可以像使用普通Future一样获取异步读文件的结果。
封装Future类
首先实现一个简单的Future模板类，用来保存异步操作的结果：
#include <mutex>
#include <condition_variable>
#include <optional>
template <typename T>
class Future {
private:
std::mutex mtx;
std::condition_variable cv;
std::optional<T> result; // 存储异步结果
bool is_done = false; // 任务是否完成标志
public:
// 设置异步结果，由任务执行方调用
void set_value(const T& value) {
std::lock_guard<std::mutex> lock(mtx);
result = value;
is_done = true;
cv.notify_one(); // 通知等待结果的线程
}
// 获取异步结果，由调用方调用，结果未就绪时阻塞
T get() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]() { return is_done; });
return result.value();
}
// 检查任务是否完成
bool done() const {
std::lock_guard<std::mutex> lock(mtx);
return is_done;
}
};
封装异步读文件接口
接下来结合aio_read和封装好的Future类，实现异步读文件的工具函数：
#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <aio.h>
#include <string.h>
#include <errno.h>
#include <memory>
#include <thread>
// 异步读文件的结果结构体，包含读取的字节数和内容
struct AsyncReadResult {
ssize_t bytes_read;
std::string content;
int error_code;
};
// 异步读文件的封装函数，返回Future对象
std::shared_ptr<Future<AsyncReadResult>> async_read_file(const std::string& file_path, size_t buffer_size = 1024) {
auto future = std::make_shared<Future<AsyncReadResult>>();
// 启动新线程处理aio_read逻辑，避免阻塞调用线程
std::thread([future, file_path, buffer_size]() {
int fd = open(file_path.c_str(), O_RDONLY);
AsyncReadResult result;
result.error_code = 0;
if (fd == -1) {
result.error_code = errno;
result.bytes_read = -1;
future->set_value(result);
return;
}
struct aiocb async_cb;
memset(&async_cb, 0, sizeof(struct aiocb));
char* buffer = new char[buffer_size];
async_cb.aio_fildes = fd;
async_cb.aio_buf = buffer;
async_cb.aio_nbytes = buffer_size - 1;
async_cb.aio_offset = 0;
if (aio_read(&async_cb) == -1) {
result.error_code = errno;
result.bytes_read = -1;
delete[] buffer;
close(fd);
future->set_value(result);
return;
}
// 等待aio_read完成
while (aio_error(&async_cb) == EINPROGRESS) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
result.bytes_read = aio_return(&async_cb);
if (result.bytes_read > 0) {
buffer[result.bytes_read] = ' ';
result.content = buffer;
} else {
result.error_code = errno;
}
delete[] buffer;
close(fd);
future->set_value(result);
}).detach();
return future;
}
使用示例
使用封装好的接口进行异步读文件，代码如下：
int main() {
// 发起异步读文件请求，立即返回Future对象
auto future = async_read_file("test.txt");
// 主线程可以继续处理其他逻辑
std::cout << "异步读文件请求已发起，主线程可以继续处理其他任务" << std::endl;
// 需要结果时调用get方法获取，结果未就绪时会阻塞
AsyncReadResult result = future->get();
if (result.error_code == 0 && result.bytes_read > 0) {
std::cout << "读取到的文件内容：" << result.content << std::endl;
std::cout << "读取字节数：" << result.bytes_read << std::endl;
} else {
std::cerr << "读取文件失败，错误码：" << result.error_code << std::endl;
}
return 0;
}
注意事项
在使用aio_read和Future模式结合实现异步文件读写时，需要注意以下几点：
- aio_read是POSIX标准接口，在Windows平台下没有原生支持，如果需要跨平台可以使用操作系统对应的异步IO接口或者第三方库
- 封装Future类时需要注意线程安全，结果的设置和获取都需要加锁保护，避免数据竞争
- 异步操作完成后要及时释放相关资源，比如关闭文件描述符、释放缓冲区内存，避免资源泄漏
- 如果不需要获取异步操作的结果，可以不用Future模式，直接发起aio_read操作后不等待结果即可
异步文件读写适合IO密集型场景，如果文件很小且读写频率很低，同步读写反而更简单高效，不需要过度设计。