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

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

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

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

#include <iostream>
#include <fstream>
#include <thread>
#include <mutex>

std::mutex fileMutex;

void writeToFile(const std::string &filename, const std::string &message) 
{
    std::lock_guard<std::mutex> 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<std::mutex> 是一种RAII风格的锁管理方式，自动管理互斥锁的生命周期。

2. 读写锁（Shared Mutex）

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

#include <iostream>
#include <fstream>
#include <thread>
#include <shared_mutex>

std::shared_mutex fileMutex;

void readFromFile(const std::string &filename) 
{
    std::shared_lock<std::shared_mutex> 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<std::shared_mutex> 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 <iostream>
#include <fstream>
#include <thread>
#include <mutex>
#include <queue>
#include <vector>
#include <functional>
#include <condition_variable>

class ThreadPool 
{
public:
    ThreadPool(size_t numThreads);
    ~ThreadPool();
    void enqueueTask(const std::function<void()>& task);

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> 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<void()> task;
                {
                    std::unique_lock<std::mutex> lock(queueMutex);
                    condition.wait(lock, [this] { return stop || !tasks.empty(); });
                    if