C++线程中调用类的非静态成员函数：从原理到避坑指南

1次阅读

共计 2799 个字符，预计需要花费 7 分钟才能阅读完成。

当我们在 C ++ 中尝试将类的非静态成员函数直接传递给 std::thread 时，经常会遇到 invalid use of non-static member function 的编译错误。这是因为非静态成员函数隐含了一个 this 指针参数，而线程函数期望的是一个普通函数指针。

传统的 C 风格解决方案是使用全局函数配合 void* 参数传递对象指针，但这种方法存在明显的类型安全隐患，且破坏了面向对象的封装性。

这是 C ++11 以来最简洁的解决方案。lambda 表达式可以捕获当前对象的 this 指针，从而在内部调用成员函数。

class Worker {
public:
    void doWork() { /*...*/}
    void start() {m_thread = std::thread([this] {this->doWork(); });
    }
private:
    std::thread m_thread;
};

std::bind可以将成员函数绑定到特定对象实例上，创建一个可调用对象。

class Worker {
public:
    void doWork() { /*...*/}
    void start() {m_thread = std::thread(std::bind(&Worker::doWork, this));
    }
private:
    std::thread m_thread;
};

对于需要维护状态的场景，可以创建一个函数对象来封装成员函数调用。

class Worker {
public:
    void operator()() {doWork(); }
    void doWork() { /*...*/}
    void start() {m_thread = std::thread(*this);
    }
private:
    std::thread m_thread;
};

下面是一个完整的线程安全任务队列实现，展示了如何正确使用 lambda 表达式启动工作线程：

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

class TaskQueue {
public:
    TaskQueue() : m_stop(false) {m_worker = std::thread([this] {this->processTasks(); });
    }

    ~TaskQueue() {
        {std::unique_lock<std::mutex> lock(m_mutex);
            m_stop = true;
        }
        m_condition.notify_all();
        if (m_worker.joinable()) {m_worker.join();
        }
    }

    void addTask(std::function<void()> task) {
        {std::unique_lock<std::mutex> lock(m_mutex);
            m_tasks.push(std::move(task));
        }
        m_condition.notify_one();}

private:
    void processTasks() {while (true) {std::function<void()> task;
            {std::unique_lock<std::mutex> lock(m_mutex);
                m_condition.wait(lock, [this] {return !m_tasks.empty() || m_stop;
                });

                if (m_stop && m_tasks.empty()) {return;}

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

    std::thread m_worker;
    std::queue<std::function<void()>> m_tasks;
    std::mutex m_mutex;
    std::condition_variable m_condition;
    bool m_stop;
};

对象生命周期管理 ：确保线程结束时对象仍然存在。可以考虑使用std::shared_ptr 和std::enable_shared_from_this。
调用约定差异 ：成员函数默认使用__thiscall 调用约定，而线程函数期望的是 __stdcall 或__cdecl。上述方案都正确处理了这个差异。
使用 C ++20 的 std::jthread：它会在析构时自动 join，避免忘记 join 导致的问题。

// C++20 示例
class Worker {
public:
    void doWork() { /*...*/}
    void start() {m_thread = std::jthread([this] {this->doWork(); });
    }
private:
    std::jthread m_thread;
};

支持任意参数类型：可以通过模板和完美转发来扩展方案，支持任意参数类型的成员函数。
带返回值的异步调用 ：可以使用std::packaged_task 和std::future来实现带返回值的异步成员函数调用。

class AsyncCaller {
public:
    template<typename R, typename... Args>
    std::future<R> asyncCall(R (AsyncCaller::*func)(Args...), Args... args) {auto task = std::packaged_task<R()>(std::bind(func, this, std::forward<Args>(args)...)
        );
        auto future = task.get_future();
        std::thread(std::move(task)).detach();
        return future;
    }

    int compute(int x, int y) {return x + y;}
};

// 使用示例
AsyncCaller caller;
auto result = caller.asyncCall(&AsyncCaller::compute, 10, 20);
std::cout << result.get() << std::endl; // 输出 30

你可以在 Godbolt 上验证这些代码，确保它们通过 clang -Wall -Wextra 检查。

在 C ++ 多线程编程中调用非静态成员函数需要特别注意对象生命周期和线程安全。lambda 表达式是最简洁现代的解决方案，而 std::bind 和仿函数在某些场景下也有其优势。无论选择哪种方法，都要确保线程安全，并处理好对象生命周期问题。C++20 引入的 std::jthread 进一步简化了线程管理，值得在新项目中使用。

正文完