Qt多线程文件操作：主线程打开文件、子线程写入是否可行？

我实现了一个AsyncFileWriter类，支持异步写入文件——写入时数据先存入临时缓冲区，由另一个线程读取缓冲区并同步写入文件。

现在有两个疑问：

1. 我知道线程共享内存空间，但在一个线程创建并打开文件，在另一个线程写入数据是否存在问题？
2. 若该操作可行，下述示例代码是否完全有效且无错误？（示例仅展示核心逻辑，省略细节）

补充说明：我需要在创建文件的线程中打开文件，因为若打开文件出错，我希望立即返回错误，而非等待线程启动、在子线程尝试打开文件后再终止线程并输出错误。

class AsyncFileWriter final : public QThread
{
    Q_OBJECT

private:

    QFile*              p_file;
    mutable QMutex      m_mutex;
    QVector<QByteArray> m_tempBuffer;
    QWaitCondition      m_waitCondition;
    std::atomic_bool    m_stopRequested;

public:

    void stop() noexcept
    {
        if (isRunning()) {
            m_stopRequested.store(true);
            QMutexLocker locker(&m_mutex);
            m_waitCondition.wakeOne();
        }
    }

    bool start(const QString& aFileName) noexcept
    {
        if (isRunning()) {
            return false;
        }
        if (aFileName.isEmpty()) {
            return false;
        }
        p_file = new QFile(aFileName);
        if (!p_file->open(QIODevice::WriteOnly)) {
            delete p_file;
            p_file = nullptr;
            return false;
        }
        return true;
    }

    // void wait() noexcept;
    void write(const QByteArray& aData) noexcept
    {
        if (!aData.isEmpty()) {
            QMutexLocker locker(&m_mutex);
            m_tempBuffer.push_back(aData);
            m_waitCondition.wakeOne();
        }
    }

    explicit AsyncFileWriter(QObject* aParrent) :
        QThread(aParrent),
        p_file(nullptr),
        m_mutex(),
        m_tempBuffer(),
        m_waitCondition(),
        m_stopRequested(false)
    {}

    AsyncFileWriter& operator=(const AsyncFileWriter&) = delete;
    AsyncFileWriter& operator=(AsyncFileWriter&&)      = delete;
    AsyncFileWriter(const AsyncFileWriter&)            = delete;
    AsyncFileWriter(AsyncFileWriter&&)                 = delete;
    
    virtual ~AsyncFileWriter() override
    {
        if (isRunning()) {
            stop();
            (void) wait(UINT64_MAX);
        }
    }

private:

    void run() noexcept override
    {
        auto writeAllData = [&]() -> void {
            QMutexLocker locker(&m_mutex);
            if (!m_tempBuffer.isEmpty()) {
                const QVector<QByteArray> buffer(std::move(m_tempBuffer));
                locker.unlock();
                for (const auto& dataFragment : buffer) {
                    const qint64 written = p_file->write(dataFragment);
                    if (written != dataFragment.size()) {
                        return p_file->error();
                    }
                }
                if (!p_file->flush()) {
                    return p_file->error();
                }
                return QFileDevice::FileError::NoError;
            }
        };
        
        while (true) {
            m_mutex.lock();
            (void) m_waitCondition.wait(&m_mutex);
            m_mutex.unlock();
            if (writeAllData() != QFileDevice::FileError::NoError) {
                break;
            }
            if (m_stopRequested.load()) {
                m_stopRequested.store(false);
                (void) writeAllData();
                break;
            }
        }
        p_file->close();
        delete p_file;
        p_file = nullptr;
        m_mutex.lock();
        m_tempBuffer.clear();
        m_mutex.unlock();
    }

};

1. 跨线程使用已打开的QFile是否可行？ #

Qt的QFile类本身不是线程安全的，但你的场景满足安全前提：仅在一个线程（子线程）中执行文件的写入、刷新、关闭操作，主线程只负责初始化打开文件，且没有多线程同时操作同一个QFile实例。这种情况下跨线程使用是完全可行的，不会有线程安全问题。

2. 现有代码的错误与问题分析 #

你的代码存在多个编译错误和潜在逻辑问题：

• writeAllData lambda返回类型矛盾：lambda声明返回void，但内部使用return p_file->error();返回枚举值，直接导致编译失败，需将返回类型改为QFileDevice::FileError。
• 线程启动逻辑缺失：start函数仅完成文件打开，但未调用QThread::start()启动子线程，导致run()永远不会执行，缓冲区数据无法写入文件。
• stop函数的竞态风险：先修改原子变量m_stopRequested再加锁唤醒，可能出现子线程刚检查完变量就被设置为true但未被唤醒的情况，需在锁保护下修改变量并唤醒。
• 条件变量等待逻辑冗余：当前循环被唤醒后直接解锁处理数据，未做唤醒原因判断，容易出现无效唤醒重复处理的情况。
• 错误反馈缺失：写入/刷新失败时仅终止循环，未向主线程传递错误信息，调用者无法感知写入失败。
• 资源清理的潜在风险：run函数末尾删除p_file，虽start函数检查了isRunning()，但需确保p_file生命周期完全由子线程管理。

核心修正建议 #

（1）修复writeAllData返回类型 #

auto writeAllData = [&]() -> QFileDevice::FileError {
    QMutexLocker locker(&m_mutex);
    if (m_tempBuffer.isEmpty()) {
        return QFileDevice::NoError;
    }
    const QVector<QByteArray> buffer(std::move(m_tempBuffer));
    locker.unlock();
    for (const auto& dataFragment : buffer) {
        const qint64 written = p_file->write(dataFragment);
        if (written != dataFragment.size()) {
            return p_file->error();
        }
    }
    return p_file->flush() ? QFileDevice::NoError : p_file->error();
};

（2）补充线程启动逻辑 #

在start函数末尾添加线程启动调用：

bool start(const QString& aFileName) noexcept
{
    // 原有逻辑...
    QThread::start();
    return true;
}

（3）优化stop函数的锁逻辑 #

void stop() noexcept
{
    if (!isRunning()) return;
    QMutexLocker locker(&m_mutex);
    m_stopRequested.store(true);
    m_waitCondition.wakeOne();
}

（4）优化run循环的等待逻辑 #

void run() noexcept override
{
    auto writeAllData = /* 修正后的lambda */;

    while (true) {
        QMutexLocker locker(&m_mutex);
        // 仅在停止请求或缓冲区有数据时唤醒
        m_waitCondition.wait(&m_mutex, [&]() {
            return m_stopRequested.load() || !m_tempBuffer.isEmpty();
        });

        bool shouldStop = m_stopRequested.load();
        QFileDevice::FileError error = QFileDevice::NoError;

        if (!m_tempBuffer.isEmpty()) {
            const QVector<QByteArray> buffer(std::move(m_tempBuffer));
            locker.unlock();
            error = writeAllData();
            locker.relock();
        }

        if (error != QFileDevice::NoError || shouldStop) {
            if (shouldStop) {
                locker.unlock();
                (void)writeAllData();
                locker.relock();
            }
            break;
        }
    }

    if (p_file) {
        p_file->close();
        delete p_file;
        p_file = nullptr;
    }
    m_tempBuffer.clear();
}

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