C++ 为什么strand:：post（）没有等效的strand:：wrap（）？

的行为被定义为创建一个functor，该functor在调用时将执行

strand:：dispatch（）

。我最近在我们的一个应用程序中遇到了一个bug，它执行以下顺序：

my_great_function(..., s.wrap(a), s.wrap(b));

应用程序保证由

s.wrap（a）

创建的函子在

s.wrap（b）

之前被调用。但是，存在一个竞争条件，即第一个函子在链外部调用，因此延迟调用，而第二个函子在链内部调用并立即执行。这违反了应用程序在

b

之前的

a

排序假设，并导致未定义的行为

---

使用

strand:：post（）

而不是

strand:：dispatch（）

是解决这一问题的一种方法，但没有像使用

strand.wrap（）那样简单的方法。我可以创建帮助函数来通过strand进行发布，我想知道是否有更简单的方法？
纯粹猜测为什么
strand.wrap
等效于
strand.post
不存在：


我找不到哪里有人正式提出在功能请求中需要
strand.wrap（）
等效项的理由
基于
strand.wrap（）
最常见的用法，它很可能根据
strand.dispatch（）
来实现，以优化组合操作的中间处理程序。用户的完成处理程序可以在满足完成条件后立即调用，而不必为延迟调用发布完成处理程序


最简单的解决方案可能是将串传递到
my_great\u函数
旁边的
a
和
b
处理程序。如果
my_great_函数
需要特定的处理程序调用顺序，那么让
my_great_函数
保证顺序而不是将责任传递给调用者似乎是可以接受的，因为调用者可能忽略了必要的顺序。另一方面，如果<代码> MySuthGuangy函数< /C>是相当通用的，在处理程序中需要特定的调用顺序，然后考虑在直接或间接暗示排序的结构中传递处理程序，如<代码> STD:：tuple < /C> > /<
虽然这两种解决方案都不提供通用的可重用解决方案，但它可能是最简单的解决方案。官方支持的解决方案将是使用自定义处理程序类型，此外还提供了通过来说明操作的中间处理程序和完成处理程序的功能。以下是一个完整的示例，主要基于：

这两种
wrap\u post
解决方案都可能会给定义的函数带来一定程度的复杂性。
顺便说一句，似乎没有文件保证
post
ed functor会按照它们发布的顺序被调用…@Igor我想是的，看。哦，对了！谢谢，我在文件里错过了这个。如果是这样，那么io_服务：：post（）也有同样的含义，很高兴知道我们依赖于一个记录在案的行为：：）。。。当然，我指的是在一个线程中调用
io\u service:：run
。@SamMiller当然没有这样的保证！函数参数的计算顺序在C++中未指定
#include <iostream>

#include <boost/asio.hpp>

/// @brief Custom handler wrapper type that will post into its dispatcher.
template <typename Dispatcher,
          typename Handler>
class post_handler
{
public:
  typedef void result_type;

  post_handler(Dispatcher dispatcher, Handler handler)
    : dispatcher_(dispatcher),
      handler_(handler)
  {}

  void operator()()
  {
    dispatcher_.post(handler_);
  }

  template <typename Arg1>
  void operator()(Arg1 arg1)
  {
    dispatcher_.post(boost::bind(handler_, arg1));
  }

  template <typename Arg1, typename Arg2>
  void operator()(Arg1 arg1, Arg2 arg2)
  {
    dispatcher_.post(boost::bind(handler_, arg1, arg2));
  }

  Dispatcher dispatcher_;
  Handler handler_;
};

// Custom invocation hooks for post_handler.  These must be declared in 
// post_handler's associated namespace for proper resolution.

template <typename Function, typename Dispatcher, typename Handler>
inline void asio_handler_invoke(Function& function,
    post_handler<Dispatcher, Handler>* this_handler)
{
  this_handler->dispatcher_.post(
      boost::asio::detail::rewrapped_handler<Function, Handler>(
        function, this_handler->handler_));
}

template <typename Function, typename Dispatcher, typename Handler>
inline void asio_handler_invoke(const Function& function,
    post_handler<Dispatcher, Handler>* this_handler)
{
  this_handler->dispatcher_.post(
      boost::asio::detail::rewrapped_handler<Function, Handler>(
        function, this_handler->handler_));
}

/// @brief Factory function used to create handlers that post through the
///        dispatcher.
template <typename Dispatcher, typename Handler>
post_handler<Dispatcher, Handler>
wrap_post(Dispatcher dispatcher, Handler handler)
{
  return post_handler<Dispatcher, Handler>(dispatcher, handler);
}

/// @brief Convenience factory function used to wrap handlers created from
///        strand.wrap.
template <typename Dispatcher, typename Handler>
post_handler<Dispatcher, 
             boost::asio::detail::wrapped_handler<Dispatcher, Handler> >
wrap_post(boost::asio::detail::wrapped_handler<Dispatcher, Handler> handler)
{
  return wrap_post(handler.dispatcher_, handler);
}

boost::asio::io_service io_service;
boost::asio::strand strand(io_service);
boost::asio::deadline_timer timer(io_service);

void a() { std::cout << "a" << std::endl; }
void b() { std::cout << "b" << std::endl; }
void c() { std::cout << "c" << std::endl; }
void d() { std::cout << "d" << std::endl; }
void noop() {}

void my_great_function()
{
  std::cout << "++my_great_function++" << std::endl;
  // Standard dispatch.
  strand.dispatch(&a);

  // Direct wrapping.
  wrap_post(strand, &b)();

  // Convenience wrapping.
  wrap_post(strand.wrap(&c))();

  // ADL hooks.
  timer.async_wait(wrap_post(strand.wrap(boost::bind(&d))));
  timer.cancel();
  std::cout << "--my_great_function--" << std::endl;
}

int main()
{
  // Execute my_great_function not within a strand.  The noop
  // is used to force handler invocation within strand.
  io_service.post(&my_great_function);
  strand.post(&noop);
  io_service.run();
  io_service.reset();

  // Execute my_great_function within a strand.
  std::cout << std::endl;
  io_service.post(strand.wrap(&my_great_function));
  strand.post(&noop);
  io_service.run();
}

++my_great_function++
--my_great_function--
a
b
c
d

++my_great_function++
a
--my_great_function--
b
c
d
/// @brief Class used to adapter the wrapped_handler's Dispatcher type
///        requirement to post handlers instead of dispatching handlers.
template <typename Dispatcher>
struct post_adapter
{
  post_adapter(Dispatcher& dispatcher)
    : dispatcher_(dispatcher)
  {}

  template <typename Handler>
  void dispatch(const Handler& handler)
  {
    dispatcher_.post(handler);
  }

  Dispatcher dispatcher_;
};

/// @brief Factory function used to create handlers that post through an
///        adapted dispatcher.
template <typename Dispatcher, typename Handler>
boost::asio::detail::wrapped_handler<post_adapter<Dispatcher>, Handler>
wrap_post(Dispatcher& dispatcher, Handler handler)
{
  typedef post_adapter<Dispatcher> adapter_type;
  return boost::asio::detail::wrapped_handler<
    adapter_type, Handler>(adapter_type(dispatcher), handler);
}

/// @brief Convenience factory function used to wrap handlers created from
///        strand.wrap.
template <typename Dispatcher, typename Handler>
boost::asio::detail::wrapped_handler<
  post_adapter<Dispatcher>, 
  boost::asio::detail::wrapped_handler<Dispatcher, Handler> >
wrap_post(boost::asio::detail::wrapped_handler<Dispatcher, Handler> handler)
{
  return wrap_post(handler.dispatcher_, handler);
}