C++多线程高效单词计数求助：段错误排查与优化方案

兄弟，你的代码里藏着几个致命的线程安全问题，咱们一步步拆解，再给你靠谱的优化方案：

为什么会出现Segmentation Fault？ #

你的段错误和异常行为，根源是这几个问题：

• 共享输入流的不安全访问：std::ifstream的getline根本不是线程安全的！两个线程同时调用它，会直接破坏流的内部状态，导致内存读写错误——这就是段错误的主要原因。
• 无保护的共享变量竞争：line、odd、even这些变量都是两个线程直接读写的，没有任何同步保护。比如线程A正在往line里写数据，线程B同时读取，就会拿到残缺的字符串；odd和even各自切换的逻辑也会混乱，导致同一行被重复统计或者完全漏掉。
• 逻辑错误的行划分：两个线程各自维护自己的奇偶标记，没有同步机制，标记状态根本不可能保持一致，行的划分逻辑从根上就错了。

更优的实现方案（不使用线程池，支持指定线程数） #

我给你推荐两种实用方案，分别适配不同场景：

方案一：预读所有行到内存，再拆分任务（适合中小文件） #

这个方案逻辑最简单，完全没有锁竞争，性能拉满：

1. 先单线程把所有行读入内存中的vector，彻底避免多线程操作文件流的问题。
2. 根据指定的线程数，把vector分成N个连续区间，每个线程负责处理自己的区间，统计局部单词数。
3. 所有线程完成后，主线程汇总所有局部计数器得到总数。

示例代码：

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

// 假设你的count_words_in_line函数已经实现
size_t count_words_in_line(const std::string& line);

int main(int argc, char* argv[]) {
    // 可通过命令行参数指定线程数，比如输入 ./program 4 就是4线程
    int num_threads = (argc > 1) ? std::stoi(argv[1]) : 4;
    std::ifstream infile("input.txt");
    if (!infile.is_open()) {
        std::cerr << "Failed to open file!" << std::endl;
        return 1;
    }

    // 单线程预读所有行到内存
    std::vector<std::string> lines;
    std::string line;
    while (std::getline(infile, line)) {
        lines.push_back(line);
    }
    infile.close();

    // 创建线程和局部计数器数组
    std::vector<std::thread> threads;
    std::vector<size_t> local_counters(num_threads, 0);

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([i, num_threads, &lines, &local_counters]() {
            // 计算当前线程负责的行区间
            size_t start = i * lines.size() / num_threads;
            size_t end = (i == num_threads - 1) ? lines.size() : (i + 1) * lines.size() / num_threads;
            
            size_t local_count = 0;
            for (size_t j = start; j < end; ++j) {
                local_count += count_words_in_line(lines[j]);
            }
            local_counters[i] = local_count;
        });
    }

    // 等待所有线程完成任务
    for (auto& t : threads) {
        t.join();
    }

    // 汇总所有线程的局部结果
    size_t total_words = 0;
    for (size_t cnt : local_counters) {
        total_words += cnt;
    }
    std::cout << "Total words: " << total_words << std::endl;

    return 0;
}

方案二：按文件块拆分处理（适合大文件，无法全装入内存） #

如果文件太大，内存装不下，咱们可以按文件的字节区间拆分，每个线程独立打开文件流处理自己的区间——注意要处理行边界，避免把一行拆成两半：

示例代码：

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

size_t count_words_in_line(const std::string& line);

int main(int argc, char* argv[]) {
    int num_threads = (argc > 1) ? std::stoi(argv[1]) : 4;
    std::string filename = "input.txt";
    std::ifstream infile(filename, std::ios::binary);
    if (!infile.is_open()) {
        std::cerr << "Failed to open file!" << std::endl;
        return 1;
    }

    // 获取文件总大小
    infile.seekg(0, std::ios::end);
    std::streampos file_size = infile.tellg();
    infile.seekg(0, std::ios::beg);
    infile.close();

    std::vector<std::thread> threads;
    std::vector<size_t> local_counters(num_threads, 0);

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([i, num_threads, file_size, filename, &local_counters]() {
            std::ifstream local_infile(filename, std::ios::binary);
            if (!local_infile.is_open()) {
                std::cerr << "Thread " << i << " failed to open file!" << std::endl;
                return;
            }

            // 计算当前线程负责的字节区间
            std::streampos start = i * file_size / num_threads;
            std::streampos end = (i == num_threads - 1) ? file_size : (i + 1) * file_size / num_threads;

            // 跳过起始位置的不完整行（避免拆分一行）
            if (start > 0) {
                local_infile.seekg(start);
                std::string dummy;
                std::getline(local_infile, dummy);
                start = local_infile.tellg();
            }

            std::string line;
            size_t local_count = 0;
            while (local_infile.tellg() < end && std::getline(local_infile, line)) {
                local_count += count_words_in_line(line);
            }
            local_counters[i] = local_count;
        });
    }

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

    size_t total_words = 0;
    for (size_t cnt : local_counters) {
        total_words += cnt;
    }
    std::cout << "Total words: " << total_words << std::endl;

    return 0;
}

方案优势 #

这两个方案都几乎不需要锁（最后汇总的开销可以忽略），彻底避免了线程竞争带来的性能损耗，而且可以通过命令行参数轻松指定线程数，方便你测试不同线程数下的性能表现。

内容的提问来源于stack exchange，提问作者Marek Szeles