创建并关联线程时遇错误：std::Invoke 未找到匹配重载函数

错误原因 #

runPingThread是ConnectionService类的非静态成员函数，这类函数调用时必须依赖类的实例（即隐式的this指针）。你创建线程时只传递了成员函数指针和promise参数，没有传入类的实例，导致编译器无法找到正确的调用方式，触发invoke匹配失败的错误。

另外你的代码还存在严重的生命周期问题：promiseObj是init函数的局部变量，线程启动后还会在循环中尝试访问它，但futureObj.get()会阻塞到线程第一次设置promise值，之后init函数执行完毕，promiseObj会被销毁，后续线程再操作它会触发未定义行为。

修复方案 #

1. 修正线程创建的参数 #

创建线程时，必须在成员函数指针之后传入this指针（当前类实例），再传递promise的引用：

pingThread = std::thread(&ConnectionService::runPingThread, this, std::ref(promiseObj));

2. 解决promise生命周期问题 #

std::promise只能被调用一次set_value，如果你的线程需要持续运行并多次传递结果，不能用单个promise，得改用其他同步机制；如果只需要单次结果，就调整线程逻辑，设置完promise后退出循环：

单次结果的修正版本

// 线程函数：设置完promise后退出循环
void runPingThread(std::promise<int>& promiseObj) {
    ping();  // 执行一次ping操作
    int result = 42;
    promiseObj.set_value(result);
    stopFlag = true; // 设置停止标志，退出循环
}

void init() {
    std::promise<int> promiseObj;
    std::future<int> futureObj = promiseObj.get_future();

    // 传入this指针和promise引用
    pingThread = std::thread(&ConnectionService::runPingThread, this, std::ref(promiseObj));

    std::cout << "Waiting for result from thread..." << std::endl;
    int result = futureObj.get();
    std::cout << "Result from thread: " << result << std::endl;

    // 确保线程完成后再结束
    if (pingThread.joinable()) {
        pingThread.join();
    }
}

持续运行并传递多次结果的方案（示例）

如果需要线程持续ping并多次返回结果，改用std::queue配合std::condition_variable：

#include <queue>
#include <condition_variable>
#include <atomic>

class ConnectionService {
private:
    std::thread pingThread;
    std::atomic<bool> stopFlag{false};
    std::queue<int> resultQueue;
    std::mutex queueMutex;
    std::condition_variable cv;

    void runPingThread() {
        while (!stopFlag) {
            ping();
            std::this_thread::sleep_for(std::chrono::seconds(5));
            int result = 42;

            // 安全地将结果加入队列
            std::lock_guard<std::mutex> lock(queueMutex);
            resultQueue.push(result);
            cv.notify_one();
        }
    }

public:
    void init() {
        pingThread = std::thread(&ConnectionService::runPingThread, this);
        std::cout << "Ping service started..." << std::endl;

        // 单独线程读取结果（也可在主线程处理）
        std::thread resultReader([this]() {
            while (!stopFlag) {
                std::unique_lock<std::mutex> lock(queueMutex);
                cv.wait(lock, [this]() { return !resultQueue.empty() || stopFlag; });
                
                while (!resultQueue.empty()) {
                    int result = resultQueue.front();
                    resultQueue.pop();
                    std::cout << "Result from thread: " << result << std::endl;
                }
            }
        });

        // 记得在程序退出前join线程
        // resultReader.join();
        // pingThread.join();
    }

    void stop() {
        stopFlag = true;
        cv.notify_all();
        if (pingThread.joinable()) {
            pingThread.join();
        }
    }

    void ping() {
        // 你的ping逻辑实现
    }
};

关键注意点 #

• 非静态成员函数作为线程入口时，必须传递类实例（this）作为第二个参数。
• std::promise是单次使用的同步工具，多次传递结果要换用队列+条件变量这类机制。
• 传递给线程的变量，生命周期必须覆盖线程的运行周期，避免悬空引用或指针。

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