如何在Qt Creator中避免网络请求的回调地狱？

我编写了如下简化代码来展示我的问题：

#include <QDebug>
#include <functional>

void third()
{
    qInfo() << "finished everything!";
}

// 会使用first()下载的内容，供third使用
void second(const std::function<void()>& cb = [] {})
{
    // 必须在first()调用完成后执行

    // 执行完毕，调用回调
    cb();
}

// 会下载一些供second()使用的内容
void first(const std::function<void()>& cb = [] {})
{
    // 执行完毕，调用回调
    cb();
}

int main(int argc, char* argv[])
{
    first([=] {
        second(third);
    });

    // 或者更糟糕的写法
    first([=] {
        second([=] {
            third();
        });
    });
}

请问有没有办法避免这种回调地狱？我曾考虑创建新线程，在其中调用这些函数并阻塞线程等待执行完成，但不确定具体实现方式。首先想了解是否有无需额外线程的更优写法；其次，如果必须使用线程，该如何实现？感谢您的帮助！

这是异步编程里非常典型的回调嵌套问题，确实会随着逻辑复杂度上升变得难以维护。下面分两种方向给你解决方案：

一、无需额外线程的优雅方案 #

这些方案保持异步执行的同时，让代码逻辑线性可读，完全避开回调地狱。

1. 用Qt 6+的QPromise/QFuture链式调用 #

Qt 6引入了标准的Promise/Future模式，我们可以把原有的回调式异步函数包装成返回QFuture的形式，然后通过then()方法串联操作：

#include <QDebug>
#include <QPromise>
#include <QFuture>
#include <QApplication>

void third()
{
    qInfo() << "finished everything!";
}

QFuture<void> second()
{
    QPromise<void> promise;
    auto future = promise.future();
    
    // 模拟你的异步操作（实际场景中可能是网络请求、文件IO等）
    QMetaObject::invokeMethod(qApp, [promise = std::move(promise)]() mutable {
        // 这里执行second的核心逻辑，使用first下载的内容
        qInfo() << "second completed";
        promise.finish(); // 标记操作完成
    }, Qt::QueuedConnection);
    
    return future;
}

QFuture<void> first()
{
    QPromise<void> promise;
    auto future = promise.future();
    
    // 模拟异步下载操作
    QMetaObject::invokeMethod(qApp, [promise = std::move(promise)]() mutable {
        qInfo() << "first downloaded";
        promise.finish();
    }, Qt::QueuedConnection);
    
    return future;
}

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    
    // 链式调用，逻辑完全线性，一目了然
    first()
        .then([]() { return second(); })
        .then([]() { third(); });
    
    return app.exec();
}

这种方式既保留了异步非阻塞的特性，又让代码的执行顺序清晰可见，完全没有嵌套回调。

2. C++20协程（Qt支持） #

如果你的项目已经升级到C++20，协程是最极致的解决方案——写法和同步代码几乎一样，但底层依然是异步执行：

#include <QDebug>
#include <QFuture>
#include <QApplication>
#include <QCoroutine>

void third()
{
    qInfo() << "finished everything!";
}

QFuture<void> second()
{
    // 模拟异步操作，实际可以替换成你的耗时任务
    co_await qt_thread;
    
    qInfo() << "second done";
    co_return;
}

QFuture<void> first()
{
    co_await qt_thread;
    
    qInfo() << "first done";
    co_return;
}

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    
    // 协程里直接按顺序写，就像同步代码一样
    auto runTasks = []() -> QFuture<void> {
        co_await first();
        co_await second();
        third();
    };
    
    runTasks();
    
    return app.exec();
}

协程彻底抹平了异步和同步代码的写法差异，是目前最优雅的异步编程方式之一。

3. 利用Qt信号槽拆分逻辑 #

Qt的信号槽本身就是为解耦设计的，我们可以把每个步骤拆成独立的槽函数，通过信号触发下一步：

#include <QDebug>
#include <QObject>
#include <QApplication>

class TaskFlow : public QObject
{
    Q_OBJECT
public:
    void start()
    {
        // 启动第一个任务
        QMetaObject::invokeMethod(this, &TaskFlow::runFirst, Qt::QueuedConnection);
    }

private slots:
    void runFirst()
    {
        // 执行first的下载逻辑
        qInfo() << "first done";
        emit firstFinished();
    }

    void runSecond()
    {
        // 使用first的内容执行second逻辑
        qInfo() << "second done";
        emit secondFinished();
    }

    void runThird()
    {
        third();
    }

signals:
    void firstFinished();
    void secondFinished();
};

void third()
{
    qInfo() << "finished everything!";
}

#include "main.moc"

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    
    TaskFlow flow;
    QObject::connect(&flow, &TaskFlow::firstFinished, &flow, &TaskFlow::runSecond);
    QObject::connect(&flow, &TaskFlow::secondFinished, &flow, &TaskFlow::runThird);
    flow.start();
    
    return app.exec();
}

这种方式完全符合Qt的设计习惯，每个步骤职责单一，逻辑清晰，也没有回调嵌套的问题。

二、使用线程的阻塞式实现 #

如果你的场景允许在后台线程中阻塞执行（比如不涉及UI操作的纯后台任务），可以把异步函数改成同步版本，然后在新线程里顺序调用：

1. 改写为同步函数 #

先把原有的回调式函数改成同步执行（去掉回调参数，直接完成逻辑）：

#include <QDebug>
#include <QThread>

void third()
{
    qInfo() << "finished everything!";
}

void second()
{
    // 同步执行second的逻辑，直接使用first下载的内容
    qInfo() << "second done";
}

void first()
{
    // 同步执行下载操作
    qInfo() << "first done";
}

2. 在后台线程执行 #

可以用Qt的QThread或者标准库的std::thread来实现：

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    
    // 方式1：QThread创建工作线程
    QThread* worker = QThread::create([](){
        // 顺序调用，线程会阻塞直到每个函数执行完成
        first();
        second();
        third();
    });
    worker->start();
    // 如果需要等待线程完成再退出，可以调用worker->wait();
    
    // 方式2：std::thread实现
    /*
    std::thread worker([](){
        first();
        second();
        third();
    });
    worker.detach(); // 让线程在后台运行，不阻塞主线程
    // 或者用worker.join()，但join会阻塞主线程直到任务完成
    */
    
    return app.exec();
}

⚠️ 注意：如果这些函数涉及UI操作（比如更新控件），绝对不能直接在后台线程调用，必须通过QMetaObject::invokeMethod或者信号槽切换回主线程执行，否则会导致程序崩溃。另外，使用detach()要确保线程内的资源能正确释放，避免内存泄漏。

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