Question

代码1：

class thread_obj {
private:
    static int instances;
    bool run;
    static mutex lock;
    int threadno;
    static map<int, thread> mapOfThreads;
public:
    thread_obj():run(true)
    {
        lock.lock();
        threadno = instances++;
        thread th(thread_obj::thredfunc, this);
        mapOfThreads[threadno] = move(th);

        cout << "Thread no is " << threadno << endl;
        lock.unlock();
    }
    static void thredfunc(thread_obj* ptr)
    {
        while (ptr->run)
        {
            std::this_thread::sleep_for(100ms);
        }
    }

    void operator()()
    {
        while (run)
        {
            std::this_thread::sleep_for(100ms);
        }
    }

    void stop()
    {
        run = false;
    }

    static int getTotalthreads()
    {
        return mapOfThreads.size();
    }

    ~thread_obj()
    {
        lock.lock();
        stop();
        if (mapOfThreads[threadno].joinable())
            mapOfThreads[threadno].join();
        mapOfThreads.erase(threadno);
        cout << "Destroyed " << threadno << endl;
        lock.unlock();
    }
};
int thread_obj::instances = 0;
mutex thread_obj::lock;
map<int, thread> thread_obj::mapOfThreads;

代码2：

thread_obj():run(true)
{
    lock.lock();
    threadno = instances++;
    thread th(thread_obj(), this);
    mapOfThreads[threadno] = move(th);

    cout << "Thread no is " << threadno << endl;
    lock.unlock();
}

第一个代码可以正常工作，但是更改代码2中给出的构造函数会出错。在代码1中，构造函数从静态函数创建线程。在代码2中，构造函数调用非静态operator（）

'std::invoke': no matching overloaded function found
Failed to specialize function template 'unknown-type std::invoke(_Callable &&,_Types &&...) noexcept(<expr>)'

这背后的原因是什么？（创建此代码是为了处理多个线程。）

Answer 1

构造函数中的这一行是胡说八道：

    thread th(thread_obj(), this);

这将构造另一个thread_obj()对象，然后尝试在新线程中将其传递this指针（即thread_obj*指针）来调用它。只有在operator()函数接受一个thread_obj*参数的情况下，这种方法才有效，但事实并非如此。

我认为您要执行的操作是在新线程中运行this->operator()()，因此您可以这样做：

thread th(std::ref(*this));

这将创建对*this的引用的新线程，然后像(*this)()那样调用它，它将调用operator()()。或者，重命名operator()函数以为其命名，例如：

void thread_func()
{
    while (run)
    {
        std::this_thread::sleep_for(100ms);
    }
}

然后在构造函数中，将指向成员函数的指针传递给std::thread构造函数，并以this作为对象来调用该成员函数：

thread th(&thread_obj::thread_func, this);

关于堆栈溢出的现有问题有数百个，它们说明了如何在std::thread中运行成员函数。

无法专用于功能模板'unknown-type std :: invoke（_Callable &&，_ Types && ...）noexcept（<expr>）'

1 个答案: