C++写两个子线程+回调函数，A线程执行结束后调用回调函数，B线程注册回调函数

在C++中，你可以使用`std::thread`和`std::future`结合回调函数来实现这样的场景，其中A线程执行完后调用B线程的回调函数。以下是这个例子的代码：

#include <iostream>
#include <thread>
#include <future>
#include <functional>

// B线程的回调函数类型
using BCallbackType = void(const std::string& result);

// A线程的函数，它会等待B线程完成并返回结果
void aThreadWithCallback(BCallbackType callback) {
    std::future<std::string> future = std::async(std::launch::async, doExpensiveTask); // 异步执行任务

    try {
        std::string result = future.get();
        std::cout << "A thread received result from B: " << result << std::endl;
        // 执行完A任务后调用B线程的回调
        callback(result);
    } catch (const std::exception& e) {
        std::cerr << "Error in A thread: " << e.what() << std::endl;
    }
}

// B线程的函数，接收结果并在适当时候触发回调
void bThread(CallbackType callback) {
    std::string result = "Task completed by B";
    callback(result); // 注册的回调函数，在B线程内部调用
}

// A线程的模拟任务
std::string doExpensiveTask() {
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return "Result from B";
}

int main() {
    // 创建B线程并注册回调
    std::thread bThreadInstance(bThread, std::ref(callbackFromA));

    // B线程的回调函数
    auto callbackFromA = [](const std::string& result) { std::cout << "Received callback from A: " << result << std::endl; };

    // 创建A线程，并传入B线程的回调函数
    std::thread aThreadInstance(aThreadWithCallback, std::ref(callbackFromA));

    // 等待A线程结束
    aThreadInstance.join();

    // 关闭B线程
    bThreadInstance.join();

    return 0;
}

在这个例子中，A线程先创建一个异步任务`doExpensiveTask`，然后在获取到结果后调用B线程的回调函数。B线程直接在其内部调用了回调函数。