文件读写进阶之多线程/多进程读写【c++】

在C++中，多线程读写文件需要特别小心，以避免数据竞态（Race Condition）和死锁（Deadlock）等问题。以下是几种常见的多线程读写文件的方式：

1. 使用互斥锁（Mutex）保护文件操作

互斥锁是控制并发访问资源的常用方式。在多线程读写文件时，可以使用互斥锁来确保每次只有一个线程可以访问文件，从而避免数据竞态。

#include

#include

#include

#include

std::mutex fileMutex;

void writeToFile(const std::string &filename, const std::string &message)

{

std::lock_guard lock(fileMutex); // 锁住互斥锁

std::ofstream outFile(filename, std::ios::app);

if (outFile.is_open())

{

outFile << message << std::endl;

}

}

void threadFunction(const std::string &filename)

{

for (int i = 0; i < 10; ++i)

{

writeToFile(filename, "Thread writing " + std::to_string(i));

}

}

int main()

{

std::string filename = "output.txt";

std::thread t1(threadFunction, filename);

std::thread t2(threadFunction, filename);

t1.join();

t2.join();

return 0;

}

说明：

std::mutex 用于控制对共享资源（文件）的访问。

std::lock_guard 是一种RAII风格的锁管理方式，自动管理互斥锁的生命周期。

2. 读写锁（Shared Mutex）

C++17 引入了std::shared_mutex，允许多个线程同时读取文件，但在有线程写入文件时阻止其他线程读取。适用于读多写少的场景。

#include

#include

#include

#include

std::shared_mutex fileMutex;

void readFromFile(const std::string &filename)

{

std::shared_lock lock(fileMutex); // 共享锁，用于读取

std::ifstream inFile(filename);

std::string line;

while (std::getline(inFile, line))

{

std::cout << line << std::endl;

}

}

void writeToFile(const std::string &filename, const std::string &message)

{

std::unique_lock lock(fileMutex); // 独占锁，用于写入

std::ofstream outFile(filename, std::ios::app);

if (outFile.is_open())

{

outFile << message << std::endl;

}

}

void readThread(const std::string &filename)

{

readFromFile(filename);

}

void writeThread(const std::string &filename, const std::string &message)

{

writeToFile(filename, message);

}

int main()

{

std::string filename = "output.txt";

std::thread t1(readThread, filename);

std::thread t2(writeThread, filename, "Thread writing");

t1.join();

t2.join();

return 0;

}

说明：

std::shared_lock 用于读取操作，允许多个线程同时持有。

std::unique_lock 用于写入操作，确保写入时没有其他线程在读取或写入。

3. 使用线程池和任务队列

为了高效处理大量文件操作任务，可以使用线程池和任务队列，将所有的文件操作任务提交到一个线程池中，按顺序执行，确保线程安全。

#include

#include

#include

#include

#include

#include

#include

#include

class ThreadPool

{

public:

ThreadPool(size_t numThreads);

~ThreadPool();

void enqueueTask(const std::function& task);

private:

std::vector workers;

std::queue> tasks;

std::mutex queueMutex;

std::condition_variable condition;

bool stop;

};

ThreadPool::ThreadPool(size_t numThreads) : stop(false)

{

for (size_t i = 0; i < numThreads; ++i)

{

workers.emplace_back([this]

{

while (true)

{

std::function task;

{

std::unique_lock lock(queueMutex);

condition.wait(lock, [this] { return stop || !tasks.empty(); });

if