如何用QtConcurrent实现类似Promise.all的多方法并行执行并合并结果？

你提到的需求——并行执行多个返回字符串的方法并合并结果，在Qt里确实有几种简洁的实现方式，完全可以对标JS的Promise.all。下面我给你两种最常用的方案：

方案一：同步等待所有任务完成（类似Promise.all后用await） #

如果你的场景可以阻塞当前线程等待所有任务结束，用QFutureSynchronizer是最省心的选择。它会自动管理多个QFuture，并等待全部完成，之后你可以直接收集每个任务的结果：

#include <QtConcurrent>
#include <QFutureSynchronizer>
#include <QList>
#include <QDebug>

// 假设这是你的三个返回字符串的方法
QString fetchDataA() {
    // 模拟耗时操作
    QThread::sleep(1);
    return "Data from Method A";
}

QString fetchDataB() {
    QThread::sleep(2);
    return "Data from Method B";
}

QString fetchDataC() {
    QThread::sleep(1);
    return "Data from Method C";
}

int main() {
    QFutureSynchronizer<QString> taskSynchronizer;

    // 把三个方法提交为并行任务
    taskSynchronizer.addFuture(QtConcurrent::run(fetchDataA));
    taskSynchronizer.addFuture(QtConcurrent::run(fetchDataB));
    taskSynchronizer.addFuture(QtConcurrent::run(fetchDataC));

    // 阻塞等待所有任务完成
    taskSynchronizer.waitForFinished();

    // 收集所有结果到列表
    QList<QString> mergedResults;
    for (const auto& future : taskSynchronizer.futures()) {
        mergedResults.append(future.result());
    }

    // 输出结果，顺序和你提交任务的顺序一致
    qDebug() << "Merged results:" << mergedResults;
    return 0;
}

这个方案的优势是代码简洁，不需要手动管理每个任务的完成状态，QFutureSynchronizer会帮你搞定一切。

方案二：异步监听任务完成（类似Promise.all的回调） #

如果不想阻塞主线程，希望任务完成后自动触发结果合并，那可以用QFutureWatcher来监听每个任务的finished信号，实时收集结果：

#include <QtConcurrent>
#include <QFutureWatcher>
#include <QList>
#include <QCoreApplication>
#include <QDebug>

QString fetchDataA() {
    QThread::sleep(1);
    return "Data from Method A";
}

QString fetchDataB() {
    QThread::sleep(2);
    return "Data from Method B";
}

QString fetchDataC() {
    QThread::sleep(1);
    return "Data from Method C";
}

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    QList<QString> mergedResults;
    int completedTasks = 0;
    const int totalTasks = 3;

    // 封装一个创建监听器的工具函数
    auto setupTaskWatcher = [&](const QFuture<QString>& future) {
        auto* watcher = new QFutureWatcher<QString>();
        QObject::connect(watcher, &QFutureWatcher<QString>::finished, [&, watcher]() {
            // 收集当前任务的结果
            mergedResults.append(watcher->result());
            completedTasks++;

            // 所有任务完成后处理结果
            if (completedTasks == totalTasks) {
                qDebug() << "All tasks done! Merged results:" << mergedResults;
                app.quit(); // 退出事件循环
            }

            watcher->deleteLater(); // 清理资源
        });
        watcher->setFuture(future);
    };

    // 提交三个并行任务并设置监听器
    setupTaskWatcher(QtConcurrent::run(fetchDataA));
    setupTaskWatcher(QtConcurrent::run(fetchDataB));
    setupTaskWatcher(QtConcurrent::run(fetchDataC));

    return app.exec();
}

这种方式完全异步，不会阻塞主线程，适合GUI应用场景——避免界面卡顿。

为什么不用QtConcurrent::mapped？ #

你提到mapped一次仅能执行一个方法，这点是对的：mapped的设计是对一个序列中的每个元素应用同一个函数，比如给一个字符串列表，每个字符串都调用同一个处理函数。而你的需求是执行三个不同的独立方法，所以mapped并不适配这种场景，还是上面两种方案更直接。

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