【问题标题】:How can I use shared_ptr using PostThreadMessage?如何使用 PostThreadMessage 使用 shared_ptr?
【发布时间】:2014-09-04 13:51:05
【问题描述】:

我想升级我的 MFC 生产代码以在调用其他窗口或线程时使用 std::shared_ptr 智能指针。这样的调用是SendMessage、PostMessage 和PostThreadMessage,它们通过wparam 和lparam,它们分别是unsigned int 和long。目前,我创建一个类对象,新建一个对象,调用传递一个指向该对象的指针,在接收端使用该对象,然后将其删除。

由于shared_ptr 在我的其余代码中运行良好,我想至少探索一下为什么我不能对 Windows 调用执行相同操作。

当前通话:

auto myParams = new MyParams(value1, value2, value3);
PostThreadMessage(MSG_ID, 0, reinterpret_cast< LPARAM >( myParams );

ReceivingMethod::OnMsgId( WPARAM wParam, LPARAM lParam)
{
  auto myParams = reinterpret_cast< MyParams * >( lParam );
  ... // use object
  delete myParams;
}

到类似 C++11 的智能指针调用:

std::shared_ptr< MyParams > myParams( new MyParams( value1, value2, value3 ) );
PostThreadMessage( MSG_ID, 0, ???myParams??? );

ReceivingMethod::OnMsgId( WPARAM wParam, LPARAM lParam )
{
  auto myParams = ???lParam???;
  ... // use object
}

编辑 1:

@Remy Lebeau:这是修改为使用 unique_ptr 传递方法的示例代码,但是,在传递对象时,我的代码中存在泄漏:

struct Logger
{
  Logger()
  {
    errorLogger = ( ErrorLogger * )AfxBeginThread( RUNTIME_CLASS( ErrorLogger ), THREAD_PRIORITY_BELOW_NORMAL );
  }

  ~Logger()
  {
    // gets properly dtor'ed upon app exit
  }

  void MakeLogMsg( ... );

  ErrorLogger * errorLogger;
  std::unique_ptr< LogParams > logParams;
};

Logger logger;
std::recursive_mutex logParamsRecursiveMu; // because of multiple requests to lock from same thread

struct ErrorLogger : public CWinThread
{
  ErrorLogger()
  {
  }

  ~ErrorLogger()
  {
    // gets properly dtor'ed before logger upon app exit
  }

  afx_msg void OnLog( WPARAM wParam, LPARAM lParam );
};

void Logger::MakeLogMsg( ... )
{
  // construct msg from logparams 

  // make msg smart object using unique ptr and send to errorlogger thread queue
  logParams = std::make_unique< LogParams >();

  // set logparams

  // with the addition of the mutex guard, the leaks are gone
  logParamsRecursiveMu.lock();
  logger.errorLogger->PostThreadMessage( ONLOG_MSG, 0, reinterpret_cast< LPARAM >( logParams.get() ) );
  logParams.release(); // no longer owns object
  logParamsRecursiveMu.unlock();
}

void ErrorLogger::OnLog( WPARAM wParam, LPARAM lParam )
{
  std::unique_ptr< LogParams > logParams( reinterpret_cast< LogParams * >( lParam ) );
}

请注意,当我注释掉 unique_ptr 的传递时,泄漏消失了。我的代码与您使用这种方法并有效的代码有何不同?

编辑2:

关于@Remy Lebeau 的回答显示如何使用std::unique_ptr 代替std::shared_ptr,我在下面的评论中表示“......没有额外的对象要实现。没有明显的缺点。”。好吧,这并不完全正确。必须为每种不同类型的消息创建MyParams 对象。有些应用程序可能只有几种类型,但有些可能有 100 种或更多。每次我想在另一边执行一个函数时,我都必须制作一个新的结构,它有一个构造函数,它接受目标调用的所有参数。如果有很多,实施起来非常繁琐且难以维护。

我认为只需传递参数就可以消除结构构建阶段。

显然有新的 C++1x 结构可以帮助实现这一点。一个可能是std::forward_as_tuple,它“构造一个对 args 中参数的引用的元组,适合作为函数的参数转发。”

对于我的应用程序,我通过模板化 MyParams 解决了这个问题,但对于任何想要避免添加大量结构的人,他可能想要考虑使用元组等。

编辑 3:@RemyLebeau 的答案 1 和 @rtischer8277 的答案 5 都是正确的。不幸的是,StackOverflow 不能识别多个正确答案。这个 StackOverflow 限制反映了一个有缺陷的心理语言学假设,即语言上下文对于同一语言组是通用的,但事实并非如此。 (参见 Roger Harris 关于固定代码语言神话的“综合语言学简介”,第 34 页)。在回复我最初的帖子时,@RemyLebeau 根据发布的代码所描述的上下文回答了这个问题,该代码显示了newed MyParams(参见编辑 2:了解更多解释)。很久以后,在答案 5 (rtischer8277) 中,我自己根据问题的原始措辞回答了这个问题,该问题询问是否可以使用 PostThreadMessage 跨线程使用 std::shared_ptr。作为一个合理的结果,我已将正确答案重新分配给@RemyLebeau,它是第一个正确答案。

编辑4: 我在这篇文章中添加了第三个合法答案。请参阅以 @Remy Lebeau 和 @rtischer8277 开头的第 6 个答案,到目前为止,我已为我的原始帖子提交了两个答案……。这个方案的效果是把跨线程访问变成了概念上简单的RPC(远程过程调用)。虽然这个答案展示了如何使用future 来控制所有权和同步,但它没有展示如何创建一个具有任意数量参数的消息对象,这些参数可以安全地用于PostThreadMessage 调用。该功能已在 StackOverflow 的 Answer 中解决,以发出 passing a parameter pack over a legacy function signature using forward_as_tuple。

【问题讨论】:

  • 我认为这里的大问题是myParams 的生命周期,他们在PostThreadMessage 调用之后还能存活多久(我认为它们是基于“堆栈”的?
  • 你可以传递一个动态分配的 std::shared_ptr。我认为您的具体示例没有任何用处,但如果您需要保留共享所有权,在某些情况下可能有意义。您仍然需要删除 shared_ptr 实例(不是 MyParams 实例,它将由 shared_ptr 管理)。
  • 如果myParams 的生命周期存在于处理OnMsgId 中的消息之后,那么您可以让MyParams 派生自enable_shared_from_this,以共享生命周期,但我不知道你会赢得什么。
  • 我的示例试图表达我认为 shared_ptr 惯用语可能如何在 MFC 调用惯用语中使用,尽管我还没有看到如何使用。目前,我正在传递 shared_ptr 对象的原始指针,但这有其缺点。也不能使用weak_ptr,因为它只报告对象是否仍然存在。
  • 您最多可以将指针传递给 shared_ptr。您必须在堆上分配它以使其保持活力。这当然没用。小心一切看起来都像钉子一样的方法,你以前的一切都很好。

标签: c++11 mfc tuples future sendmessage


【解决方案1】:

由于消息参数必须超过调用范围,因此在此示例中使用 shared_ptr 没有多大意义,因为源 shared_ptr 很可能在消息处理之前超出范围。我建议改用unique_ptr,这样您就可以在指针飞行时release(),然后在处理完消息后获得它的新所有权:

SendingMethod::SendMsgId( ... )
{
    ...

    std::unique_ptr<MyParams> myParams( new MyParams(value1, value2, value3) );
    if (PostThreadMessage(MSG_ID, 0, reinterpret_cast<LPARAM>(myParams.get()))
        myParams.release();

    ...
}

ReceivingMethod::OnMsgId( WPARAM wParam, LPARAM lParam)
{
    std::unique_ptr<MyParams> myParams( reinterpret_cast<MyParams*>(lParam) );
    ... // use object
}

【讨论】:

  • 我已经确认这个答案是有效的。它保留了 C++11 智能指针的习惯用法,即不必与删除竞争,并且不需要额外的对象来实现。没有明显的缺点。
  • 唯一的缺点是如果消息没有被处理,那么对象就会被泄露。如果您想避免这种情况,则必须在其他地方跟踪对象。
  • 我的项目保证消息传递,所以使用 unique_ptr 仍然有效。
  • 确实存在与这种非常合乎逻辑的解决方案相关的内存泄漏,即释放 unique_ptr 的所有权并在 Windows 调用的另一端重新拥有它。无论我将 myParams 对象放在哪里——就像在上面的示例中一样,作为周围类的成员,甚至作为一个全局对象——都会发生一次泄漏,并且最后一个 unique_ptr 实例化不会得到处理。有人看到逻辑缺陷吗?
  • @pbyhistorian 请注意,消息处理程序可以使用ReplyMessage()(当InSendMessage() 返回true 时)使SendMessage() 返回其调用方,而无需完全退出消息处理程序。例如,在转移所传递指针的所有权之后。这不是常见的做法,但需要注意。
【解决方案2】:

一种方式:

  1. 从 std::enable_shared_from_this&lt;Params&gt; 或从启用共享的基类派生您的 Params。

  2. 在消息中传递一个原始指针。

  3. 在接收端,调用p-&gt;shared_from_this()获取新的shared_ptr。

请注意,对于发布消息,与发送相反,您需要确保在处理消息时对象仍然有效。

一种方法是使用静态shared_ptr。为了确保正确的协议,您可以限制shared_from_this 的可访问性并将其包装在一个getter 中,以消除静态shared_ptr。免责声明:我没有这样做,因此可能存在问题。

【讨论】:

  • @RemyLebeau 的回答使用了 unique_ptr。我知道我的原始帖子说 shared_ptr,但鉴于他使用 unique_ptr 的回答,跨线程和窗口安全地转移所有权似乎是我真正想做的事情。
【解决方案3】:

如果这不是您的应用程序的速度关键部分,那么解决方案可能是创建一个 singleton 来保存您要传递的每个 shared_ptr。

当你需要传递一个 shared_ptr 时,你会将它存储在这个单例中,并返回一个引用它的 ID。这是您将使用 PostThreadMessage 传输的 ID。

另一方面,当收到消息时,您可以使用此 ID 检索 shared_ptr。当然,单例必须删除它对 shared_ptr 的引用。

优点:

  • 这种技术很容易实现,并且应该与您现有的代码兼容,
  • 使用单例存储 shared_ptr 将确保它们在消息传输之前不会被销毁。

缺点:

  • 如果从未收到消息会怎样? (PostThreadMessage 甚至可能吗?)你必须确保 shared_ptr 不会永远留在你的单例中。
  • 访问 shared_ptr 需要在 std::map 中找到它(如果同时有很多消息,它可能会变慢),
  • 由于这是一个多线程代码,您需要使用互斥锁来保护对映射的访问 (shared_ptr are thread-safe),
  • 您将需要一个可以存储任何类型的 shared_ptr 并且可以存储在 std::map 中的对象。考虑拥有一个可以存储任何 shared_ptr 的模板类,并且该模板类将派生自非模板基类(我不记得这个技巧的名称了)。
  • 显然,如果您需要在不同进程之间发送消息,这种技术将不起作用。

【讨论】:

  • 虽然这个答案可能有效,但@RemyLebeau 的答案没有明显的缺点。
  • "如果从未收到消息会怎样?(PostThreadMessage 甚至可能吗?)" - 是的,如果您不小心的话,这是可能的。接收消息循环可能在收到消息之前结束(应用程序关闭、处理消息时崩溃等)。或者在接收线程(模态 UI 等)中运行的一段代码可能会在消息到达处理程序之前抽取消息队列并丢弃消息。等
【解决方案4】:

问题已解决。我将 std::make_unique 包装到 logParams.release() 语句中的上面修改后的示例代码中的互斥锁中。添加这两个语句后没有报告泄漏。

这些语句的作用是防止 errorLogger 线程在唯一对象的所有权被释放之前删除它。

还是有问题。

在注释掉添加的 2 个互斥语句时,仍然没有泄漏。他们应该重新出现。不仅通过添加语句修复了泄漏,而且永久修复了我的开发机器上两个实例中的泄漏。第二个实例的代码没有被更改。这个问题看起来像一个编译器错误。幸运的是,我在另一台机器上进行了夜间备份,但它仍然表现出泄漏行为。

但很清楚的是,只要对象包装在互斥体中,Remy Lebeau 的 unique_ptr 方法通过 Windows 消息调用传递智能 ptr 就可以工作。他警告说,如果存在寿命问题,这些物体会泄漏。

【讨论】:

  • 您只需要一个互斥锁,就可以在多个线程之间共享变量。如果您查看我的示例,情况并非如此,因此不需要线程同步。对消息发送者的每次调用都使用一个局部变量来持有一个新的本地创建对象的所有权,直到发布的消息获得它的所有权,然后接收者在处理消息时获得所有权。
【解决方案5】:

@Remy Lebeau 和 @rtischer8277 到目前为止已为我的原始帖子提交了两个答案。前者使用std:unique_ptr,后者使用std::shared_ptr。两个答案都有效,但有相同的限制。 @Rem Lebeau 是这样说的:……这样你就可以在指针飞行时释放()指针,然后在处理完消息后获得它的新所有权……,这破坏了智能指针习语。所需要的是一个像远程过程调用 (RPC) 一样工作的解决方案,它从计算开始就已经存在(RPC、DCE、CORBA、SQL 和数据库,以及 GOOBLE/BING/YAHOO 搜索,更不用说所有网页了)迄今为止的链接和查询)。很明显,易于编程的跨线程 RPC MFC 功能有明确的动机。 SendMessage 是 RPC,用于对从 CWnd(又名“窗口”)派生的对象进行同线程调用。我在这里提供的解决方案就是我称之为“SendThreadMessage”的非解决方案。

您将在下面看到一个演示此功能的项目。 背景:PostThreadMessage 有两个“重载”。一种适用于 windows 并在其签名中使用被调用线程的m_hThreadID,另一种是CWinThread::PostThreadMessage,不包含任何 windows(读取:CWnd 派生)类。 ThatsAlok 在 CodeProject 的 PostThreadMessage Demystified 中展示了一个实际示例和对前一种重载的清晰解释。

虚幻的“SendThreadMessage”功能的第二种解决方法是简单地向另一个线程发送一条消息,当该过程完成时,将一条消息发送回去。 Gorlash:……我为此使用了一个双消息系统,主线程向任务处理程序线程发送一条消息,当任务处理程序完成后,它又向调用者发送另一条消息(这两个是用户定义的消息)……,OReubens:……一个 PostThreadMessage 和一个 Post back(到窗口或作为线程消息)是更安全/更好/更可控的出路。注意:SendMessageCallback 不是解决方案,因为跨线程的回调不是同步的。

这两个“重载”引起了很多混乱,并且没有关于CWinThread::PostThreadMessage 重载的明确代码示例。与干净的同步 RPC 调用相比,我没有看到任何解决方案不乏味。

所以这是我的解决方案:永远不要释放 unique_ptr 对象的所有权,直到它自然超出范围。使用&lt;future&gt; 创建一个promise,该promise 通过LPARAM 参数自动传递给另一个线程。在接收线程中,使用传入对象成员中发送的所需数据执行代码(即远程过程)。当远程线程完成处理并在同一个对象中设置其输出数据时,使用promise 的set_value 通知第一个线程中等待的未来对象调用已完成,结果存储在@987654337 @ 目的。这使用简单的现代 C++ future 构造有效地模拟了 SendMessage 同步 RPC 功能,而无需解决或破坏 C++ 的正常所有权语义。

这里是注释的 VS2015 项目的链接,它演示了它是如何工作的:SendThreadMessage.sln

SendThreadMessage.sln 是一个检查了 ATL 和 MFC 的 VS 控制台项目。控制台输出显示 unique_ptrs 正在创建并超出称为 pingThread 和 pongThread 的范围。 mainfrm 线程被阻塞,而 ping 和 pong 线程交替发送消息给对方(间隔一秒)。每个 PostThreadMessage 和 futures 都使用普通 MFC 和现代 C++ 演示了“SendThreadMessage”同步 RPC 功能。

【讨论】:

  • 您正在同步线程。可能会导致死锁。
  • @rtischer8277 请不要在另一台服务器上托管文件。问题应该是独立的,并且外部链接会随着时间的推移而中断。此外,该链接需要 OneDrive 登录名,并不是每个人都有这样的登录名。请将示例代码减少到最低限度并直接放在答案中。
【解决方案6】:

在 Edit2 中:我发现 @Remy Lebeau 的回答存在一个问题:MyParams 对象需要创建 std::unique_ptr,然后转移,然后在目标线程上重新拥有。此外,我想要在PostThreadMessage 中使用std::shared_ptrs 的最初动机仍然存在于我的应用程序中。在我的 OP 代码中,我做了 new MyParams 对象,这是 @Remy Lebeau 的答案解决的问题。原来的代码应该是:

struct MyParams { MyParams() {} int nn { 33 }; }; // doesn’t go out of scope w/r/t receiving method
...
std::shared_ptr< MyParams > myParams = std::make_shared< MyParams >();
...
PostThreadMessage( MSG_ID, 0, reinterpret_cast< LPARAM >( myParams.get() );

这里是接收代码:

void ReceivingMethod::OnMsgId( WPARAM wParam, LPARAM lParam )
{
  std::shared_ptr< MyParams > myParamsX( reinterpret_cast< MyParams* >( lParam ) ); // error
  myParamsX->nn++; // ok, nn: 35
} // throws exception when going out of scope

由于weak_ptrs 不影响所有权,那么我应该能够使用PostThreadMessage 的lParam 跨线程传输它的指针,我推断。有几个可用的weak_ptr 构造函数。使用std::weak_ptr&lt; A &gt;&amp;(ref) 构造函数。这是接收代码:

void ReceivingMethod::OnMsgId( WPARAM wParam, LPARAM lParam )
{
  std::weak_ptr< MyParams > myParamsX( reinterpret_cast< std::weak_ptr< MyParams >& >( lParam ) ); // ok: nn:34 but strong and weak refs reporting are random numbers
  //std::weak_ptr< MyParams > myParamsX( reinterpret_cast< std::weak_ptr< MyParams >& >( lParam ) ); // ok: also works
  myParamsX.lock()->nn++; // ok: nn: 35
  int nnX = myParamsX.lock()->nn; // ok: nnX: 35
} // ok: weak_ptr releases resource properly, but intellisense strong and weak ref counts are still bad

我测试了递增 myParam 和 myParamX 的 nn 成员,myParamsWptr.lock()-&gt;nn++ 和 myParams-&gt;nn++ 都可以递增智能对象。这次释放myParams 对象没有失败。我假设因为myParamsWptr 锁定了对象,所以不会出现线程访问问题。

正如预期的那样,程序没有泄漏。

为什么还要继续使用PostThreadMessage?要跨 Windows 用户界面(消息泵)线程进行通信,请使用 PostThreadMessage。我仍在寻找同样出色的现代 C++ 技术。 std::promise、std::future 和 std::get_future 可以与没有消息泵的工作线程一起正常工作。与此同时,我在 MFC C++ 应用程序中使用了PostThreadMessage。

【讨论】:

  • 您正在邮件的LPARAM 中发送原始MyParams* 指针。接收方不能将LPARAM 转换为除原始MyParams* 指针之外的任何内容。当然不是weak_ptr&amp;。正如我之前解释的,在消息运行时保持指向MyParam 对象的智能指针是危险的,因为如果智能指针在接收到消息之前超出范围,则可能会导致对象被过早销毁。这将解释您在接收器中看到的异常。而且您也不能手动修改shared_ptr 的引用计数以防止过早销毁。
  • 创建 unique_ptr 并释放它,而不是原始 ptr,也许是原子的。在接收处理程序中重新创建 unique_ptr。除非 PostThreadMessage 本身失败,否则没有泄漏的机会,这是极不可能的。
  • 这正是我的回答所显示的。除了PostThreadMessage() 失败之外还有其他可能导致泄漏的情况,如果您不小心,这些情况在其他 cmets 中进行了解释(接收消息循环未运行、模态消息循环丢弃消息等)
猜你喜欢
  • 2011-10-31
  • 2010-09-21
  • 1970-01-01
  • 2014-04-21
  • 1970-01-01
  • 2010-10-21
  • 2014-12-30
  • 2018-02-19
  • 1970-01-01
相关资源
最近更新 更多