c++ - 线程可以被重用来运行可变参数函数吗？

Question

我正在尝试在 C++ 中创建一个 boost 线程，它可以重复用于运行可以具有不同数量和类型的 args 的各种函数。

这可以用 C++11x 可变参数来完成吗？

在我的用例中，我不需要队列(如果线程繁忙，那么该方法就会失败)，但如果需要实现此“统一”功能，我会不情愿地这样做。

我不明白如何使用 bind 或 lambda 处理统一，以便一个线程可以调用不同的函数，每个函数都有自己的不同数量和类型的参数。

我大概想到了以下几点:

class WorkThread
{
public:
   WorkThread()
       {
       // create thread and bind runner to thread
       }

   ~WorkThread()
       {
       // tell runner to exit and wait and reap the thread
       }

   template<typename F,typename ... Arguments>
   void doWork(F func, Arguments... args)
       {
       if already busy
           return false;
       // set indication to runner that there is new work
       // here: how to pass f and args to runner?
       }

private:
   void runner()
        {
        while ( ! time to quit )
            {
            wait for work
            // here: how to get f and args from doWork? do I really need a queue? could wait on a variadic signal maybe?
            f(args);
            }
        }

   boost::thread* m_thread;
};

class ThreadPool
{
public:
    template<typename F, typename ... Arguments>
    bool   doWork(F func,Arguments... args)
          {
          const int i = findAvailableWorkThread();
          m_thread[i].doWork(f,args);
          }
private:
   // a pool of work threads m_thread;
};

Answer 1

应该有很多现有的问题来说明如何做到这一点。

表示任意函数对象的规范 C++11 方法是 std::function<void()> ，因此您需要一个名为 m_job 的该类型的共享对象在下面的代码中，它应该受到互斥锁的保护，并且在尚未设置时为其分配新作业:

template<typename F,typename ... Arguments>
bool doWork(F func, Arguments&&... args)
{
    std::lock_guard<std::mutex> l(m_job_mutex);
    if (m_job)
        return false;
    m_job = std::bind(func, std::forward<Arguments>(args)...);
    m_job_cond.notify_one();  
    return true;   
}

这使用 std::bind将函数对象及其参数转换为不带参数的函数对象。 std::bind 返回的可调用对象存储 func 的拷贝和每个参数，并在调用时调用 func(args...)

然后 worker 就做:

void runner()
{
    while ( ! time to quit )
    {
        std::function<void()> job;
        {
            std::unique_lock<std::mutex> l(m_job_mutex);
            while (!m_job)
                m_job_cond.wait(l);
            swap(job, m_job);
        }
        job();
    }
}

这段代码不是线程安全的:

template<typename F, typename ... Arguments>
    bool   doWork(F func,Arguments... args)
    {
        const int i = findAvailableWorkThread();
        m_thread[i].doWork(f,args);
    }

在 findAvailableWorkThread 之后返回，该线程可能会变得繁忙，因此下一行将失败。您应该检查可用性并在单个操作中通过新作业，例如

template<typename F, typename ... Arguments>
    bool   doWork(F func,Arguments... args)
    {
        for (auto& t : m_thread)
            if (t.doWork(f,args))
                return true;
        return false;
    }