PAYATHON 2026

C++ 双缓冲读取并计算 SHA256,如何避免数据竞争?

数据小陈

双缓冲可以让文件读取与 SHA256 计算重叠。原代码需要重点修复 Quit 的同步,以及读取失败、异常退出和重复调用的处理。主线程读取、后台线程计算的分工可以保留;明确记录两个缓冲区的占用状态会更容易维护。

原代码有哪些同步问题?

Quit 存在数据竞争

后台线程持有 ReadMtx 时读取 Quit,主线程却直接执行:

Quit = true;
Process_CV.notify_one();

主线程写入时没有持有同一把锁,这些访问之间没有建立必要的同步关系,可能发生数据竞争,导致未定义行为。notify_one() 本身不能保护共享变量。

此外,修改条件变量的判断状态时没有持有对应的互斥锁,还可能在工作线程检查条件后、进入等待前发出通知,导致线程无法按预期退出。

沿用现有结构时,退出路径至少应改成:

{
    std::lock_guard<std::mutex> lock(ReadMtx);
    Quit = true;
}
Process_CV.notify_one();
HashThread.join();

这只是退出路径的局部修复,还没有覆盖读取失败和异常处理。

当前实现确实能重叠读取与计算

UpdateHash() 中的 lock 一直存活到本轮循环结束,因此 SHA256_Update() 执行期间始终持有 ReadMtx。

主线程可以向 FileBlockOne 读取下一块数据,但必须等后台线程处理完 FileBlockTwo,才能取得 ReadMtx 并交换缓冲区。读取一块数据和计算另一块的哈希确实可以重叠。

Started 的通知只表示后台线程已经开始处理。当前实现依靠后台线程在计算期间持续持有 ReadMtx,保证缓冲区能够安全复用。如果只把哈希计算移到锁外,保留现有“开始处理”通知,主线程就可能过早交换缓冲区,覆盖仍在使用的数据。

因此,缩短锁的持有时间时,还需要记录缓冲区是否已经处理完成。

还需要处理读取结果和对象生命周期

原代码还有以下问题:

  • 没有检查文件是否成功打开,也没有检查 read() 实际读取的字节数。读取不足时仍按 BlockSize 计算哈希,可能把未读入或遗留的数据算进去。
  • file_size() 与后续读取之间,文件可能发生变化。预先取得的大小不能代替对读取结果的检查。
  • 工作线程启动后,若 file_size() 等操作抛出异常,局部 std::thread 仍处于可连接状态,其析构会调用 std::terminate()。
  • Ready、Quit、Started 和缓冲区都是共享状态。正常完成一次调用后,Quit 仍为 true,再次调用可能提前退出或一直等待;并发调用也不安全。
  • 如果展示的函数确实是普通自由函数,[this] 捕获不合法;只有在相应的非静态成员函数上下文中才适用。

按当前正常路径,主线程每发布一块数据都会等待 Started,后台线程则在检查 Quit 之后才设置 Started。因此,不能仅凭 if (Quit) break; 断言最后一个完整块必然被跳过;应先修复实际存在的同步问题。

用两个缓冲区维护明确的占用状态

可以把两个缓冲区组成容量为 2 的有序队列:

  1. 读取线程等待下一个缓冲区空闲,然后在锁外读取。
  2. 读取完成后,发布实际字节数并标记为占用。
  3. 计算线程按顺序处理缓冲区,处理完成后才将其标记为空闲。
  4. 到达文件末尾后,计算线程处理完剩余数据再退出。

这样既不需要交换指针,也不需要额外的“已经开始处理”通知。

下面的示例使用 C++17 即可实现。Hasher 需要提供原问题中的三个成员函数;调用方应保证 digest 指向足够容纳 SHA256 摘要的可写空间,并且执行期间没有其他线程访问同一个哈希对象。

#include <array>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <fstream>
#include <mutex>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

template <class Hasher>
void HashFileDoubleBuffered(const std::string& path,
                           Hasher& sha256,
                           std::uint8_t* digest)
{
    constexpr std::size_t BlockSize = std::size_t{1} << 24;

    struct Slot {
        std::vector<std::uint8_t> data =
            std::vector<std::uint8_t>(BlockSize);
        std::size_t size = 0;
        bool occupied = false;
    };

    std::ifstream input(path, std::ios::binary);
    if (!input) {
        throw std::runtime_error("Cannot open input file");
    }

    std::array<Slot, 2> slots;
    std::mutex mutex;
    std::condition_variable cv;
    bool done = false;
    std::exception_ptr error;

    sha256.SHA256_Init();

    std::thread worker([&] {
        try {
            std::size_t index = 0;
            for (;;) {
                std::unique_lock<std::mutex> lock(mutex);
                cv.wait(lock, [&] {
                    return error || slots[index].occupied || done;
                });

                if (error) {
                    return;
                }
                if (!slots[index].occupied) {
                    return; // Reading ended and no pending block remains.
                }

                Slot& slot = slots[index];
                const std::size_t size = slot.size;
                lock.unlock();

                sha256.SHA256_Update(slot.data.data(), size);

                lock.lock();
                slot.occupied = false;
                index = (index + 1) % slots.size();
                lock.unlock();
                cv.notify_all();
            }
        } catch (...) {
            {
                std::lock_guard<std::mutex> lock(mutex);
                if (!error) {
                    error = std::current_exception();
                }
            }
            cv.notify_all();
        }
    });

    try {
        std::size_t index = 0;
        for (;;) {
            {
                std::unique_lock<std::mutex> lock(mutex);
                cv.wait(lock, [&] {
                    return error || !slots[index].occupied;
                });
                if (error) {
                    break;
                }
            }

            Slot& slot = slots[index];
            input.read(reinterpret_cast<char*>(slot.data.data()),
                       static_cast<std::streamsize>(BlockSize));
            const auto count = input.gcount();

            if (input.bad() || (input.fail() && !input.eof())) {
                throw std::runtime_error("Cannot read input file");
            }

            if (count > 0) {
                {
                    std::lock_guard<std::mutex> lock(mutex);
                    slot.size = static_cast<std::size_t>(count);
                    slot.occupied = true;
                }
                cv.notify_all();
                index = (index + 1) % slots.size();
            }

            if (input.eof()) {
                break;
            }
        }
    } catch (...) {
        std::lock_guard<std::mutex> lock(mutex);
        if (!error) {
            error = std::current_exception();
        }
    }

    {
        std::lock_guard<std::mutex> lock(mutex);
        done = true;
    }
    cv.notify_all();
    worker.join();

    if (error) {
        std::rethrow_exception(error);
    }
    sha256.SHA256_Final(digest);
}

这里的 occupied 包含“已经读好、等待计算”和“正在计算”两种情况。工作线程计算完之后才清除该状态,因此读取线程不会覆盖正在使用的数据。

互斥锁负责发布缓冲区内容、字节数和状态,读取与哈希计算都在锁外执行。两个索引始终按文件顺序前进,最后不足整块的数据也会交给同一个工作线程处理。

示例按读取到的字节流计算哈希。如果要求读取期间文件内容保持一致,需要另外保证文件不会被修改。示例也不能立即中断已经进入系统调用的阻塞读取。

C++20 的 atomics、semaphore 和 jthread 是否有帮助?

这些工具可以用于实现相同的协议,但仍需要正确管理缓冲区所有权和退出状态。

  • std::counting_semaphore 可以表达空闲槽位和待处理槽位的数量,适合固定容量队列。文件结束和异常退出仍需要单独设计唤醒方式。
  • std::atomic::wait() 和 notify_one() 可以围绕原子状态等待。使用时需要明确状态转换及内存顺序,避免覆盖尚未处理的数据。
  • std::jthread 提供自动请求停止和连接的生命周期管理,但停止请求不会自动唤醒普通的 std::condition_variable::wait(),也不能自动取消阻塞文件读取。工作线程必须能够观察到停止并结束等待。

仅把 Quit 改成 std::atomic<bool>,可以消除该变量上的非原子读写竞争,却不能自动修复条件变量协议,也不能说明缓冲区何时可以复用。对于两个缓冲区,使用互斥锁和条件变量已经足够清楚。

哪个线程负责读取更合适?

对于这个串行哈希任务,主线程读取、工作线程计算,或工作线程读取、主线程计算,都可以形成同样的流水线。选择通常取决于主线程是否还需要处理界面、事件循环或其他协调工作。

如果主线程没有其他任务,一个主线程加一个工作线程已经足够。额外增加读取线程和计算线程,不会自动提高吞吐量。

同一份 SHA256 上下文必须按文件字节顺序更新。直接把各块交给多个线程分别计算摘要,再拼接结果,得不到原文件的标准 SHA256 摘要。

能获得多大收益?

设每块读取耗时为 R,计算耗时为 H。忽略启动、收尾和同步开销时,串行处理每块耗时约为 R + H,双缓冲流水线稳定后约为 max(R, H)。

理想加速比约为:

(R + H) / max(R, H)

当 R 远大于 H 时,加速比会接近 1,这与问题中的预期一致。实际收益应在目标设备上比较串行版与双缓冲版,并确保读取的是同一份稳定数据、得到的摘要一致。原有块大小是 16 MiB,两个缓冲区的数据空间合计约为 32 MiB;是否合适,需要结合设备内存和实际读取表现判断。

备注:内容仅供参考。