首先得明确咱们要替代的Qt核心能力：当信号发射线程和槽所属线程不一样时，自动把槽函数的调用塞进接收者线程的事件队列，让槽在目标线程的上下文里执行——不用手动加互斥锁、不用自己处理线程切换，只需要承担数据拷贝的开销，安全又省心。

下面是几个能直接对标这个行为的方案，按易用性和贴合度排序：

1. 基于C++标准库手动实现线程事件队列 #

这是最“自给自足”的方案：给每个需要接收跨线程调用的线程维护一个任务队列，线程在主循环里不断取出任务执行。用std::function封装槽逻辑，发送信号时就把任务投递到目标线程的队列里。

举个极简的实现例子：

#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <thread>

class ThreadEventLoop {
public:
    using Task = std::function<void()>;

    void post(Task task) {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_tasks.push(std::move(task));
        m_cv.notify_one();
    }

    void run() {
        while (m_running) {
            std::unique_lock<std::mutex> lock(m_mutex);
            m_cv.wait(lock, [this] { return !m_tasks.empty() || !m_running; });
            
            if (!m_running && m_tasks.empty()) break;

            auto task = std::move(m_tasks.front());
            m_tasks.pop();
            lock.unlock();
            
            task(); // 这里就在当前线程（事件循环所属线程）执行了
        }
    }

    void stop() {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_running = false;
        m_cv.notify_one();
    }

private:
    std::queue<Task> m_tasks;
    std::mutex m_mutex;
    std::condition_variable m_cv;
    bool m_running = true;
};

// 用的时候这么搞
ThreadEventLoop workerLoop;
std::thread workerThread([&] { workerLoop.run(); });

// 模拟发信号：主线程投递任务，worker线程执行
workerLoop.post([] {
    objectInAnotherThread->someSlot();
});

• 优点：完全依赖C++标准库，没额外包袱；逻辑完全可控，能精准复刻Qt的跨线程调用行为；开销很低，就是任务拷贝和队列操作那点成本。
• 缺点：得自己给每个线程维护事件循环，不像Qt那样自动把对象和线程绑定；线程的启停、生命周期都得自己手动管，有点繁琐。

2. 用Facebook Folly的Executor框架 #

Folly是工业级的C++工具库，它的Executor体系专门管任务调度。其中SerialExecutor能保证所有提交的任务在同一个线程里顺序执行，完美对应Qt里单个线程对象的槽执行逻辑——你给每个需要接收跨线程调用的对象绑定一个专属的SerialExecutor，发信号时把任务提交过去就行。

示例代码大概是这样：

#include <folly/executors/SerialExecutor.h>
#include <folly/executors/ThreadedExecutor.h>

// 先整个全局线程池当底层执行器
auto globalExecutor = std::make_shared<folly::ThreadedExecutor>();

// 给目标对象创建专属的SerialExecutor，确保任务都在同一个线程跑
auto objExecutor = folly::SerialExecutor::create(globalExecutor);

// 模拟发信号：提交任务到objExecutor，自动在目标线程执行
objExecutor->add([] {
    objectInAnotherThread->someSlot();
});

• 优点：成熟的工业级实现，不用自己造轮子；支持多种调度策略（串行、并行都有）；线程的管理全自动化，不用你操心启停。
• 缺点：得引入Folly这个第三方依赖；需要适配它的线程模型，有一点学习成本。

3. 基于Boost.Asio的io_context #

Boost.Asio的io_context本质就是个事件循环，你给每个需要接收跨线程调用的线程绑定一个io_context，用post方法投递任务，任务就会在io_context的运行线程里执行——和Qt的事件循环逻辑几乎一致。

示例：

#include <boost/asio/io_context.hpp>
#include <thread>

boost::asio::io_context workerIo;
// 加个工作守卫，避免io_context没任务就直接退出
boost::asio::executor_work_guard<boost::asio::io_context::executor_type> work(workerIo.get_executor());
std::thread workerThread([&] { workerIo.run(); });

// 模拟发信号：投递任务到workerIo，自动在worker线程执行
workerIo.post([] {
    objectInAnotherThread->someSlot();
});

• 优点：Boost是C++生态里的常客，很多项目本来就依赖它；io_context的事件循环稳定得一批，还能和异步IO结合用。
• 缺点：同样是第三方依赖；如果要给每个对象绑定独立线程，得创建多个io_context，资源开销会大一点；线程生命周期还是得自己管。

4. C++20的std::jthread + 事件队列 #

C++20新增的std::jthread自带线程停止机制，结合线程本地的任务队列，能实现更现代的轻量方案——不用手动处理线程join或者stop的逻辑，代码更简洁。

示例：

#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <thread>

class ThreadTaskQueue {
public:
    using Task = std::function<void()>;

    void post(Task task) {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_tasks.push(std::move(task));
        m_cv.notify_one();
    }

    void run(std::stop_token stoken) {
        while (!stoken.stop_requested()) {
            std::unique_lock<std::mutex> lock(m_mutex);
            m_cv.wait(lock, [this, &stoken] { return !m_tasks.empty() || stoken.stop_requested(); });
            
            if (stoken.stop_requested() && m_tasks.empty()) break;

            auto task = std::move(m_tasks.front());
            m_tasks.pop();
            lock.unlock();
            
            task();
        }
    }

private:
    std::queue<Task> m_tasks;
    std::mutex m_mutex;
    std::condition_variable m_cv;
};

// 使用方式
ThreadTaskQueue queue;
std::jthread workerThread([&](std::stop_token stoken) { queue.run(stoken); });

// 投递任务，自动在worker线程执行
queue.post([] { objectInAnotherThread->someSlot(); });

• 优点：完全基于C20标准，没额外依赖；std::jthread自动管线程停止，不用手动写join或者stop逻辑；代码更符合现代C风格。
• 缺点：需要编译器支持C++20；还是得手动维护每个线程的任务队列。

最后给你做个对比表，方便选 #

如果想完全摆脱第三方依赖，手动实现或者C++20的方案是首选；如果项目已经用了Boost或Folly，那直接用对应的框架就能快速替换Qt的跨线程信号槽逻辑，省得自己造轮子。

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