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 的有序队列:
- 读取线程等待下一个缓冲区空闲,然后在锁外读取。
- 读取完成后,发布实际字节数并标记为占用。
- 计算线程按顺序处理缓冲区,处理完成后才将其标记为空闲。
- 到达文件末尾后,计算线程处理完剩余数据再退出。
这样既不需要交换指针,也不需要额外的“已经开始处理”通知。
下面的示例使用 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;是否合适,需要结合设备内存和实际读取表现判断。
备注:内容仅供参考。
