Question

我正在为std::thread实现一个包装器，它允许我在线程执行完毕后检索任意返回值。当我使用C++11时，我使用的是较旧的ARM架构，它不支持完全支持atomic int，这意味着我无法使用std::future，std::promise， std::packaged_task，以及大部分stl线程功能（我至少得到std::thread）。我正在使用gcc 4.8.4进行测试。

在我的实现工作中，我遇到this bug，这使得我无法使用lambda捕获可变参数模板参数。不幸的是，我目前无法将编译器升级到4.9。

我正在尝试使用std::bind实施解决方法，但遇到了很多问题。我不确定这些是编译器错误还是我的实现错误。这是来源：

#include <iostream>
#include <memory>
#include <thread>

#include <unistd.h>
#include <pthread.h>

class ConcurrentTaskBase
{
public:
   ConcurrentTaskBase(int priority, const std::function<void()>& runTask)
      : m_thread(),
        m_active(true)
   {
      auto wrap = [this](int priority, const std::function<void()>& runTask)
      {
         //Unrelated pthread stuff that I commented out
//         sched_param param{priority};
//
//         int err = pthread_setschedparam(pthread_self(), SCHED_RR, &param);
//         if (err)
//            cout << "failed to set new priority: " << err << endl;

         runTask();
      };
      m_thread = std::thread(wrap, priority, runTask);
   }

   virtual ~ConcurrentTaskBase(void)
   {
      waitForCompletion();
   }

   void waitForCompletion(void)
   {
      if (m_active)
      {
         m_thread.join();
         m_active = false;
      }
   }

private:
   std::thread m_thread;
   bool m_active;
};

template<class R, class... ArgTypes>
class ConcurrentTask;

template<class R, class... ArgTypes>
class ConcurrentTask<R(ArgTypes...)> : public ConcurrentTaskBase
{
public:
   ConcurrentTask(int priority, const std::function<R(ArgTypes...)>& task, ArgTypes&&... args)
      : ConcurrentTaskBase(priority, bindTask(task, std::forward<ArgTypes>(args)...))
   {}

   std::shared_ptr<R> getReturn(void) noexcept
   {
      waitForCompletion();
      return m_storage;
   };

private:
   static std::function<void(void)> bindTask(const std::function<R(ArgTypes...)>& task, ArgTypes&&... args)
   {
      auto action = [task](ArgTypes&&... args) -> void
      {
         //Eventually m_storage = std::make_shared<R>(task(std::forward<ArgTypes>(args)...)); after bugs are fixed
         task(std::forward<ArgTypes>(args)...);
         return;
      };
      std::function<void(void)> bound = std::bind(action, std::forward<ArgTypes>(args)...);
      return bound;
   };

   std::shared_ptr<R> m_storage;
};

int testFunction(int val)
{
   std::cout << "Was given " << val << std::endl;
   return val + 10;
}

int main()
{
   ConcurrentTask<int(int)> task(20, testFunction, 5);
//   shared_ptr<int> received = task.getReturn();
//   testFunction(*received);
   return 0;
}

这是我的编译器输出：

16:31:00 **** Incremental Build of configuration Debug for project TestLinuxMint ****
make all 
Building file: ../src/TestLinuxMint.cpp
Invoking: GCC C++ Compiler
g++ -std=c++0x -O0 -g3 -Wall -pthread -c -fmessage-length=0 -MMD -MP -MF"src/TestLinuxMint.d" -MT"src/TestLinuxMint.o" -o "src/TestLinuxMint.o" "../src/TestLinuxMint.cpp"
../src/TestLinuxMint.cpp: In instantiation of ‘static std::function<void()> ConcurrentTask<R(ArgTypes ...)>::bindTask(const std::function<_Res(_ArgTypes ...)>&, ArgTypes&& ...) [with R = int; ArgTypes = {int}]’:
../src/TestLinuxMint.cpp:58:84:   required from ‘ConcurrentTask<R(ArgTypes ...)>::ConcurrentTask(int, const std::function<_Res(_ArgTypes ...)>&, ArgTypes&& ...) [with R = int; ArgTypes = {int}]’
../src/TestLinuxMint.cpp:91:53:   required from here
../src/TestLinuxMint.cpp:76:90: error: conversion from ‘std::_Bind_helper<false, ConcurrentTask<R(ArgTypes ...)>::bindTask(const std::function<_Res(_ArgTypes ...)>&, ArgTypes&& ...) [with R = int; ArgTypes = {int}]::__lambda1&, int>::type {aka std::_Bind<ConcurrentTask<R(ArgTypes ...)>::bindTask(const std::function<_Res(_ArgTypes ...)>&, ArgTypes&& ...) [with R = int; ArgTypes = {int}]::__lambda1(int)>}’ to non-scalar type ‘std::function<void()>’ requested
       std::function<void(void)> bound = std::bind(action, std::forward<ArgTypes>(args)...);
                                                                                          ^
make: *** [src/TestLinuxMint.o] Error 1

16:31:01 Build Finished (took 319ms)

问题似乎发生在line 76上，std::bind(*) to std::function<void(void)>转换失败。这段代码肯定还在开发中，但我需要通过这个问题才能继续前进。我在SO上看了很多其他帖子，但是所有这些帖子似乎都可以在变量模板参数上使用std :: bind而没有问题。

解

这是kzraq和this post提出的最终解决方案（与此问题相关）。

来源：

#include <iostream>
#include <memory>
#include <utility>
#include <vector>
#include <thread>
#include <type_traits>
#include <typeinfo>
#include <tuple>
#include <memory>

//------------------------------------------------------------------------------------------------------------
template <std::size_t... Ints>
struct idx_sequence
{
   using type = idx_sequence;
   using value_type = std::size_t;
   static constexpr std::size_t size() noexcept { return sizeof...(Ints); }
};

//------------------------------------------------------------------------------------------------------------
template <class Sequence1, class Sequence2>
struct _merge_and_renumber;

template <std::size_t... I1, std::size_t... I2>
struct _merge_and_renumber<idx_sequence<I1...>, idx_sequence<I2...> >
   : idx_sequence<I1..., (sizeof...(I1)+I2)...>
{
};

//------------------------------------------------------------------------------------------------------------
template <std::size_t N>
struct make_idx_sequence : _merge_and_renumber<make_idx_sequence<N/2>, make_idx_sequence<N - N/2> >
{
};
template<> struct make_idx_sequence<0> : idx_sequence<> { };
template<> struct make_idx_sequence<1> : idx_sequence<0> { };

//------------------------------------------------------------------------------------------------------------
template<typename Func, typename Tuple, std::size_t... Ints>
auto applyImpl(Func&& f, Tuple&& params, idx_sequence<Ints...>)
   -> decltype(f(std::get<Ints>(std::forward<Tuple>(params))...))
{
    return f(std::get<Ints>(std::forward<Tuple>(params))...);
};

template<typename Func, typename Tuple>
auto apply(Func&& f, Tuple&& params)
   -> decltype(applyImpl(std::forward<Func>(f),
               std::forward<Tuple>(params),
               make_idx_sequence<std::tuple_size<typename std::decay<Tuple>::type>::value>{}))
{
    return applyImpl(std::forward<Func>(f),
                     std::forward<Tuple>(params),
                     make_idx_sequence<std::tuple_size<typename std::decay<Tuple>::type>::value>{});
};

class ConcurrentTaskBase
{
public:
    ConcurrentTaskBase(int priority, const std::function<void()>& task)
        : m_thread(),
          m_active(true)
    {
        auto wrap = [this](int priority, const std::function<void()>& task)
        {
           //Unrelated pthread stuff that I commented out
           sched_param param{priority};

           int err = pthread_setschedparam(pthread_self(), SCHED_RR, &param);
           if (err)
              std::cout << "failed to set new priority: " << err << std::endl;

           task();
        };
        m_thread = std::thread(wrap, priority, task);
    }

    virtual ~ConcurrentTaskBase(void)
    {
        waitForCompletion();
    }

    void waitForCompletion(void)
    {
        if (m_active)
        {
            m_thread.join();
            m_active = false;
        }
    }

private:
    std::thread m_thread;
    bool m_active;
};

template<class R, class... ArgTypes>
class ConcurrentTask;

template<class R, class... ArgTypes>
class ConcurrentTask<R(ArgTypes...)> : public ConcurrentTaskBase
{
public:
    ConcurrentTask(int priority, const std::function<R(ArgTypes...)>& task, ArgTypes&&... args)
    : ConcurrentTaskBase(priority, bindTask(task, std::forward<ArgTypes>(args)...))
    {}

    std::shared_ptr<R> getReturn(void) noexcept
    {
        waitForCompletion();
        return m_storage;
    }

private:
    std::function<void(void)> bindTask(const std::function<R(ArgTypes...)>& task, ArgTypes&&... args)
    {
        auto params = std::make_tuple(args...);
        return [this, task, params](){m_storage = std::make_shared<R>(apply(task, params));};
    };
    std::shared_ptr<R> m_storage;
};

template<class... ArgTypes>
class ConcurrentTask<void(ArgTypes...)> : public ConcurrentTaskBase
{
public:
    ConcurrentTask(int priority, const std::function<void(ArgTypes...)>& task, ArgTypes&&... args)
       : ConcurrentTaskBase(priority, bindTask(task, std::forward<ArgTypes>(args)...))
    {}

private:
    std::function<void(void)> bindTask(const std::function<void(ArgTypes...)>& task, ArgTypes&&... args)
    {
        auto params = std::make_tuple(args...);
        return [this, task, params](){apply(task, params);};
    };
};

// Example stuff
struct MyStruct
{
    int x;
    int y;
};
int testFunction(MyStruct val)
{
    std::cout << "X is " << val.x << " Y is " << val.y << std::endl;
    return val.x + 10;
}

void printMe(int x)
{
    std::cout << "Printing " << x << std::endl;
}
int main()
{
    ConcurrentTask<int(MyStruct)> task(20, testFunction, {5, -21});
    std::shared_ptr<int> received = task.getReturn();
    std::cout << "Return value is " << *received << std::endl;

    ConcurrentTask<void(int)> voidTask(25, printMe, -123);
    return 0;
}

Answer 1

作为猜测，绑定假定它可以被重复调用（尤其是在左值上下文中调用时！），因此不会将rvalue参数转换为rvalue参数作为rvalue参数的绑定函数。您的代码需要哪些。那个lambda不是完美的转发！

你还在lambdas中通过引用捕获const& std::function，这只会引发悬空引用地狱。但这是一个运行时问题。作为一般规则，永远不会&捕获，除非lambda的生命周期和所有副本在当前范围内结束;在原型制作过程中绝对不要这样做，即使是'＃34;某些＆＃34;它不会成为一个问题。

我会考虑编写std::apply和index_sequence的弱版本并将参数打包到tuple然后执行apply以解压缩到目标callable。但这是一种偏见，如果理想的话就不知道。

Answer 2

这或多或少是Yakk所写的内容。也许我不能很好地理解你的想法，但对我而言，似乎你已经过度设计它并且你过早地使用std::function。此外，ArgTypes&&不会是转发/通用引用列表，因为它们不会在bindTask中推断出来。

gcc 4.8.2上的以下compiles successfully：

为C ++ 11获取自己的integer_sequence。由Xeo提供。

编写apply以将元组参数应用于函数（可能可以改进）：

template<typename Func, typename Tuple, unsigned int... is>
auto apply_impl(Func&& f, Tuple&& params, seq<is...>)
    // -> decltype(f(std::get<is>(std::forward<Tuple>(params))...)) // C++11 only
{
  using std::get; // enable ADL-lookup for get in C++14
  return f(get<is>(std::forward<Tuple>(params))...);
}

template<typename Func, typename Tuple>
auto apply(Func&& f, Tuple&& params)
    // -> decltype(apply_impl(std::forward<Func>(f), std::forward<Tuple>(params),
    //    GenSeq<std::tuple_size<typename std::decay<Tuple>::type>::value>{}))
    // C++11 only
{
    return apply_impl(std::forward<Func>(f), std::forward<Tuple>(params),
        GenSeq<std::tuple_size<typename std::decay<Tuple>::type>::value>{});
}

简化您的bindTask（虽然此时我会将其作为模板）：

auto params = make_tuple(args...);
std::function<void(void)> bound = [task,params]{ apply(task, params); };
return bound;

在C ++ 14中，[task=std::move(task),params=std::move(params)]执行以避免不必要的副本。

无法将std :: bind与variadic模板参数一起使用

2 个答案: