C++ I/O 性能优化指南

原创 于 2025-04-11 14:19:41 发布
· 815 阅读 · 16 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #性能优化 #开发语言

在高性能计算和大规模数据处理中，I/O 性能优化是提升系统整体效率的关键环节。C++ 作为一种高性能编程语言，提供了丰富的工具和机制来优化 I/O 操作。本文将详细介绍在 Linux 环境下，如何通过代码层面的优化、系统调用的选择以及多线程技术等手段，显著提升 C++ 程序的 I/O 性能。

1. 选择合适的 I/O 模式

1.1 同步 I/O 与异步 I/O

同步 I/O 操作会阻塞当前线程，直到操作完成，这可能导致性能瓶颈。相比之下，异步 I/O（如 std::async、std::future 或使用专门的异步库如 Boost.Asio）可以避免阻塞，提高程序的响应性和吞吐量。

示例：

#include <iostream>
#include <thread>
#include <future>

void asyncRead() {
    std::ifstream file("data.txt");
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    std::cout << content << std::endl;
}

int main() {
    std::future<void> future = std::async(std::launch::async, asyncRead);
    future.get(); // 等待异步操作完成
    return 0;
}
1.2 使用高效的文件操作系统调用

  • mmap：将文件映射到内存空间，避免频繁调用 read 和 write 系统调用。

  • sendfile：直接发送文件内容，避免先读取再发送。

  • readv 和 writev：批量处理 I/O 操作，减少系统调用次数。

示例：

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <iostream>

int main() {
    int fd = open("data.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        close(fd);
        return 1;
    }

    char* map = static_cast<char*>(mmap(nullptr, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
    if (map == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }

    std::cout << map << std::endl;

    if (munmap(map, sb.st_size) == -1) {
        perror("munmap");
    }
    close(fd);
    return 0;
}

2. 优化文件读写操作

2.1 大块读写

尽量使用较大的缓冲区进行读写操作，以减少系统调用的次数。例如，使用 fread 或 fwrite 时，建议使用至少 4KB（或更大的 1MB）的缓冲区。

示例：

#include <cstdio>
#include <cstring>
#include <iostream>

int main() {
    FILE* file = fopen("data.txt", "rb");
    if (!file) {
        perror("fopen");
        return 1;
    }

    const size_t bufferSize = 4096;
    char buffer[bufferSize];
    size_t bytesRead;

    while ((bytesRead = fread(buffer, 1, bufferSize, file)) > 0) {
        // 处理读取的数据
        std::cout.write(buffer, bytesRead);
    }

    fclose(file);
    return 0;
}
2.2 顺序访问

尽量以顺序方式访问磁盘，避免随机访问，因为随机访问会导致磁盘头频繁移动，降低性能。

2.3 文件系统选择

选择适合业务需求的文件系统，例如对于高性能需求的场景，可以选择 XFS 或 Btrfs。

3. 内存管理优化

3.1 减少内存拷贝

避免不必要的内存拷贝，例如通过共享内存或移动语义来传递数据。

示例：

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int[]> data(new int[1000000]);
    // 使用 data 进行操作
    return 0;
}
3.2 使用内存池

对于频繁分配和释放小块内存的情况，可以使用内存池来减少内存分配的开销。

示例：

#include <iostream>
#include <vector>

class MemoryPool {
private:
    std::vector<char*> pool;
    size_t poolSize;
    size_t blockSize;

public:
    MemoryPool(size_t poolSize, size_t blockSize) : poolSize(poolSize), blockSize(blockSize) {
        for (size_t i = 0; i < poolSize; ++i) {
            pool.push_back(new char[blockSize]);
        }
    }

    ~MemoryPool() {
        for (char* block : pool) {
            delete[] block;
        }
    }

    char* allocate() {
        if (!pool.empty()) {
            char* block = pool.back();
            pool.pop_back();
            return block;
        }
        return new char[blockSize];
    }

    void deallocate(char* block) {
        pool.push_back(block);
    }
};

int main() {
    MemoryPool pool(10, 1024);
    char* block = pool.allocate();
    // 使用 block 进行操作
    pool.deallocate(block);
    return 0;
}
3.3 利用缓存

通过缓存频繁访问的数据，减少对磁盘的读取操作。

4. 编译器优化

4.1 选择合适的编译器和优化选项

使用支持高性能优化的编译器，如 GCC 或 Clang，并启用优化选项（如 -O2 或 -O3）。

示例：

g++ -O3 -march=native -mtune=native -o program program.cpp
4.2 使用 SIMD 指令

利用 SIMD（单指令多数据）指令来加速数据处理。

示例：

#include <immintrin.h>
#include <iostream>

int main() {
    __m256i vec1 = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
    __m256i vec2 = _mm256_set_epi32(8, 7, 6, 5, 4, 3, 2, 1);
    __m256i result = _mm256_add_epi32(vec1, vec2);

    int* resultArray = reinterpret_cast<int*>(&result);
    for (int i = 0; i < 8; ++i) {
        std::cout << resultArray[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

5. 多线程和多进程

5.1 并行处理

使用多线程或多进程来充分利用多核 CPU 的计算能力。

示例：

#include <iostream>
#include <thread>
#include <vector>

void processChunk(const std::vector<int>& data, size_t start, size_t end) {
    for (size_t i = start; i < end; ++i) {
        // 处理数据
        std::cout << data[i] << " ";
    }
}

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    size_t numThreads = 4;
    size_t chunkSize = data.size() / numThreads;

    std::vector<std::thread> threads;
    for (size_t i = 0; i < numThreads; ++i) {
        size_t start = i * chunkSize;
        size_t end = (i == numThreads - 1) ? data.size() : (start + chunkSize);
        threads.emplace_back(processChunk, std::ref(data), start, end);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}
5.2 线程池

使用线程池来管理线程，避免频繁创建和销毁线程带来的开销。

示例：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;

public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queueMutex);
                        this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                        if (this->stop && this->tasks.empty()) {
                            return;
                        }
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

    template <class F, class... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }
            tasks.emplace([task]() { (*task)(); });
        }
        condition.notify_one();
        return res;
    }
};

int main() {
    ThreadPool pool(4);

    auto future1 = pool.enqueue([] { return 1; });
    auto future2 = pool.enqueue([] { return 2; });

    std::cout << "Result 1: " << future1.get() << std::endl;
    std::cout << "Result 2: " << future2.get() << std::endl;

    return 0;
}

6. 减少锁竞争

6.1 减少锁的粒度

使用多个小锁代替一个大锁，减少锁的持有时间。

6.2 使用读写锁

在读多写少的场景中，使用读写锁可以提高性能。

示例：

#include <iostream>
#include <shared_mutex>
#include <thread>
#include <vector>

class SharedData {
private:
    std::shared_mutex mutex;
    int data;

public:
    SharedData(int initialData) : data(initialData) {}

    int readData() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data;
    }

    void writeData(int newData) {
        std::unique_lock<std::shared_mutex> lock(mutex);
        data = newData;
    }
};

void reader(SharedData& sharedData) {
    for (int i = 0; i < 10; ++i) {
        std::cout << "Reader: " << sharedData.readData() << std::endl;
    }
}

void writer(SharedData& sharedData) {
    for (int i = 0; i < 10; ++i) {
        sharedData.writeData(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main() {
    SharedData sharedData(0);
    std::thread readerThread(reader, std::ref(sharedData));
    std::thread writerThread(writer, std::ref(sharedData));

    readerThread.join();
    writerThread.join();

    return 0;
}
6.3 无锁编程

在可能的情况下，使用无锁编程技术。

7. 其他优化技巧

7.1 预读取和预写入

使用 madvise 系统调用告知内核内存访问模式，以便更高效地使用内存。

示例：

#include <sys/mman.h>
#include <iostream>

int main() {
    int* data = new int[1000000];
    madvise(data, sizeof(int) * 1000000, MADV_WILLNEED);

    // 使用 data 进行操作
    delete[] data;
    return 0;
}
7.2 大页支持

启用大页支持，减少页表开销。

示例：

echo 10 > /proc/sys/vm/nr_hugepages
7.3 网络优化

选择合适的网络协议，并调整协议栈参数以优化网络延迟或吞吐量。

示例：

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <iostream>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1) {
        perror("connect");
        close(sockfd);
        return 1;
    }

    const char* message = "Hello, Server!";
    send(sockfd, message, strlen(message), 0);

    char buffer[1024];
    recv(sockfd, buffer, sizeof(buffer), 0);
    std::cout << "Received: " << buffer << std::endl;

    close(sockfd);
    return 0;
}

总结

通过上述方法，可以显著提升 C++ 程序的 I/O 性能。具体优化方案需要根据实际应用场景进行选择和调整。希望本文能帮助你在开发高性能 C++ 应用时，更好地理解和应用这些优化技巧。

【C++ 性能优化】C++ 分支预测优化
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-14 737
分支预测是现代处理器用来加速指令流水线的技术。每当代码中出现如`if`语句这样的条件分支时，处理器需要决定执行哪一个分支。由于从内存中取指令并解码需要时间，现代处理器会尝试预测哪个分支最可能被执行，并提前加载相关指令。如果预测正确，处理器就避免了等待，从而大幅提高了执行速度。相反，如果预测失败，处理器则需要撤销错误的指令执行结果，从正确的分支重新开始，这一过程会导致显著的性能损失。
⭐⭐⭐⭐⭐Linux C++性能优化秘籍：从编译器到代码，探究高性能C++程序的实现之道
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-06 2843
高性能C++编程涉及多个方面，包括编译器优化、C++代码性能优化基本原则、C++对象管理与性能优化、多线程编程与性能优化、Linux系统调用优化等。通过学习和掌握这些要点，程序员可以有效地提高C++程序在Linux环境下的性能。接下来的章节将对这些核心要点进行详细的介绍。
c/c++性能优化--I/O优化（上）
王教余的专栏
07-14 4649
这节本想直接介绍I/O优化的，后来思考一下有必要对常用的I/O操作函数的特点介绍一下，这样要好些。下面就先介绍和I/O有关的库函数（以C99为准） 不同的操作系统有不同的文件管理方式，现行的主要有FAT（fileallocation table）、FAT32、NTFS(new technoly file system)、NWFS(netware file system)以及UFS(unix file system)当然还有一些分布式文件管理系统如：AFS(andrew filesystem)、DFS、Mic
C++中优化IO效率
路飞小迷弟的博客
09-17 1985
本文首发于我的个人Blog阿西BUG，欢迎大家批评指正 前言 最近在刷LeetCode的时候，发现时间靠前的答案总是会有以下类似代码 static const auto xxx = []() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); return nullptr; }();...
IO优化 C++ IO使用优化技巧
qq_68308828的博客
07-02 987
I/O 优化是提高程序性能的关键手段之一，通过使用缓冲 I/O、批量 I/O 操作、高效 I/O 库、非阻塞 I/O、多线程/异步 I/O、内存映射文件等技术，可以显著提高程序的 I/O 性能。同时，选择合适的数据结构和优化文件系统配置也可以进一步提升性能。在实际应用中，应该根据具体情况选择合适的优化技术，以达到最佳的性能优化效果。
《C++高效编程：内存与性能优化》第十二章：优化IO
Enjoy Coding
09-19 1997
C++性能优化__优化IO
yinhua405的博客
03-09 399
第一，缩短调用链 void stream_read_streambuf(std::istream& f, std::string& result) { std::stringstream s; s << f.rdbuf(); std::swap(result, s.str()); } 第二，减少重新分配 void stream_read_string_reserve(std::istream& f, std::string& result) { f.se
C++性能优化实战指南
07-14
### C++性能优化实战指南 #### 一、理解C++编译器优化 在C++编程中，编译器优化是提升程序性能的关键步骤之一。它不仅能够帮助开发者编写更高效的代码，还能够显著提高程序的执行效率。编译器优化可以分为多个级别...
C++常用库函数及I/O、Strings操作指南
C++标准库不仅为开发者提供了丰富的函数和类，而且这些函数和类都是高度优化的，能够提供良好的性能。因此，合理地使用标准库可以编写出既高效又易于维护的代码。然而，值得注意的是，在使用这些库函数时，需要确保...
【Linux系统编程】文件I/O、进程控制与通信、内存管理等系统接口详解：提供全面的API操作指南了文档的主要内容
最新发布
05-02
内容概要：本文档提供了 Linux 系统编程接口的全面概述，涵盖了文件 I/O、文件和目录管理、系统数据与进程环境信息、内存分配、进程凭证、时间处理、文件系统操作、进程控制、信号处理、定时器、线程管理、进程间...
探寻C++最快的读取文件的方案 C++ IO优化
08-12
探索了文件的快速读取方法， 非常详细地比较了scanf、cin、fread、read、mmap、Pascal read的读取速度
C/C++ IO总结
To be a crazy and happy coder!
11-06 6330
正如Effective C++所讲：C++就是一个语言联邦。他是一个多面手。对于同一个问题往往有很多种解决办法，具体采用那种办法就交给程序员去选择。因此本文对C++文件IO的整理就得分为两个面：C方式，C++方式。程序员可根据自己所在团队选择合适且统一的IO方式。   一. 基础知识 1.1文件类型：ASCII文件和二进制文件 首先我不保证文件类型只有这两种。但理解这两种文件对学习文件IO
C++性能优化：高效的IO操作
夏天的狂风的专栏
06-14 499
C++面试题
如何快速地进出——C++ 读写数据 I/O 性能优化
LSEC小陆的博客
07-11 3689
如何快速地进出——C++ 读写数据 I/O 性能优化 I 即 Input 表示进，O 即 Output 表示出，任何的进出，如果你没有掌握正确的姿势，就容易让工具累趴，如上图所示。比如说，读写数据，如果没有掌握正确的 IO 姿势，你的计算机很容易就累了。 在多媒体技术高速发展的今天，数据的积累成指数级别的增长。数据的挖掘要求我们对海量的数据进行输入，进而处理与分析之后，将结果输出。很多时候，在算法处理数据耗时较短的情况的，数据的 I/O 成了减少时间、提高程序性能的瓶颈。 要改进 I/O 性能，一个最
【学习笔记】I \ O 优化
JR_xwg的博客
08-24 529
读入、输出优化
C++加快IO操作的方法
zhjs_abc的博客
09-16 1596
如果C++代模块中没有使用C的输入或输出函数，而是只用到了C++的输入输出函数，则可以使用std::ios::sync_with_stdio(false)来关闭同步。这个函数是一个“是否兼容stdio”的开关，C++为了兼容C，保证程序在使用了std::printf和std::cout的时候不发生混乱，将输出流绑到了一起。解绑后，速度会有质的提升； 此外，std::cin与std::cout也有绑定，导致每次std::cout执行后并在执行sstd::cin时都会刷新输出缓冲区，解除同步能够进一步加快IO.
c++读入优化(模板)
喵喵喵？
08-14 763
今年的多校(nowcoder)，被卡常卡到自闭， 然而隔壁队挂个读入挂就过了,emmmmmm， 自此以后，自带大常数，逐渐进入卡常的节奏，哈哈哈哈哈   之所以会有读入优化这种东西是因为getchar()的速度比scanf和cin都要快，所以在读入数据比较多的时候可以尝试读入优化，顺带inline一下，会更快一点. scanf实际上也是读入字符，不过我们给了他格式说明符(例如d)，所以他...
[C\C++]读入优化【技巧】
skysys的研究小屋
04-12 3687
int read(){ int x=0; char ch=getchar(); while (ch'9') ch=getchar(); while (ch>='0' && ch<='9'){ x=x*10+ch-'0'; ch=getchar(); } return x; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

这个懒人

感谢打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值