如何在工作线程中取消操作时防止内存泄漏？

Question

目前我正在开发一个包含数学分析的桌面应用程序。我使用 qt 进行 GUI 和用 C++ 编写的项目。 当用户开始分析时，我打开一个工作线程并启动一个进度条。到目前为止一切正常，当用户取消操作时问题开始。操作很复杂，我正在使用多个函数和对象，我在多个位置分配/释放内存有时。我想了解在取消操作中恢复应该做什么。因为可能存在内存泄漏。我应该使用哪种模式或方法来保证取消操作的鲁棒性和安全性？

我的想法是抛出异常，但操作确实很复杂，所以我应该将 try-catch 放入所有函数中，还是有更通用的方法，模式..

编辑：问题是我的对象在作用域之间传输，所以共享指针或自动指针没有解决我的问题， 标记想法可以，但我认为它需要这么多代码，应该有一个简单的方法。

Answer 1

您应该尝试将动态分配的资源保存在自动（位于堆栈上的本地）哨兵对象中，当这些资源超出范围时，这些对象会在其析构函数中释放这些资源。 这样您就可以知道它们不会泄漏，即使函数由于异常而退出。 您可能还想研究用于在例程之间共享内存的boost 库shared_ptr。

Answer 2

首先，在多线程应用程序中抛出异常是不确定的，因为没有标准的方法来处理它们（它们是否传播到其他线程？调度程序？main()？其他地方？）。 至少在您获得内置标准化线程的 C++0x 库之前是这样。

目前，使用 RAII 更有意义（这将保证在作用域退出时清除所有资源（包括内存），无论它是由于成功还是失败而存在），并将某种状态代码传递回最有意义的线程（例如调度程序）。

此外，十多年来一直不鼓励直接取消线程。 正如 Simon Jensen 所建议的那样，最好告诉线程自行停止并让线程处理清理工作。

Answer 3

这个问题没有通用的解决方案。

一些可能的策略：

• 有时使用shared_ptr和朋友会有所帮助
• 如果您不希望取消功能使您的算法变得混乱，请考虑抛出。 捕获顶层函数并从那里进行清理。
• 无论您放入堆栈而不是堆上，都不会导致泄漏
• 对于堆上在类之间有大量指针的大型结构，通常是严格提供一种方法来释放整个内存结构的问题。
• 您是否考虑过在取消时丢弃的内存池中放置新的内容？

但无论如何，要有策略，否则你会感到痛苦。

Answer 4

答案是，这取决于您操作的复杂程度。

这里有一些方法。
1）如前所述，在操作中放置一个“取消”标志，并让该操作定期（接近）间隔轮询取消标志，可能至少与更新进度栏一样频繁。 当用户点击取消时，然后点击取消例程。

现在，对于这种情况下的内存处理，我已经通过几种方式完成了。 我更喜欢使用智能指针或 STL 对象，它们会在超出范围时自行清理。 基本上，在具有析构函数的对象内部声明您的对象，该析构函数将为您处理内存清理； 当您创建这些对象时，会为您创建内存，并且当对象超出范围时，内存会自动删除。 您还可以添加类似“dispose”方法的内容来处理内存。 它可能看起来像这样：

class MySmartPointer { 
     Object* MyObject;
     MySmartPointer() { MyObject = new Object(); }
     ~MySmartPointer() { if (MyObject != null) { delete MyObject; MyObject = null; }}
     void Dispose() { if (MyObject != null) { delete MyObject; MyObject = null; } }
     Object* Access() { return MyObject; }
 }

如果你想变得非常聪明，你可以将该类模板化为任何对象的通用类，甚至可以拥有数组等。 当然，您可能必须在访问对象之前检查该对象是否已被释放，但是当您直接使用指针时，它们会中断。 您还可以内联 Access 方法，这样在执行期间就不会花费函数调用的费用。

2) goto 方法。 在前面声明你的内存，在最后删除，当你点击cancel方法时，调用goto转到方法的末尾。 我认为某些程序员可能会因此对你处以私刑，因为 goto 被认为是极其糟糕的风格。 由于我学习了 basic 和“goto 10”作为循环方式，所以它并没有让我那么害怕，但你可能必须在代码审查期间回答学究，所以你最好有一个非常好的解释为什么你选择这个而不是选项 1。3

）将其全部放入进程中，而不是线程中。 如果可以的话，将所有要操作的信息序列化到磁盘，然后在另一个程序中运行复杂的分析。 如果该程序死掉了，那就这样吧，它不会破坏您的主应用程序，并且如果您的分析如此复杂并且在 32 位计算机上，您可能需要所有内存空间才能运行。 您只需将进度读/写到磁盘，而不是使用共享内存来传递进度信息，并且可以立即取消。 实施起来有点棘手，但并非不可能，而且可能更稳定。

Answer 5

由于您使用的是 Qt，因此您可以利用 QObject 的父内存系统。

您说您在工作线程运行期间分配和释放内存。 如果每个分配都是 QObject 的一个实例，为什么不将其作为当前 QThread 对象的父对象呢？

MyObject * obj = new MyObject( QThread::currentThread() );

您可以随时删除它们，这很好，但如果您错过了一些，它们将在 QThread 释放时被清除。

请注意，当您告诉工作线程 QThread 取消时，您必须等待它完成才能删除 QThread 实例。

workerThread->cancel();  // reqfuest that it stop
workerThread->wait();    // wait for it to complete
delete workerThread;     // deletes all child objects as well

如果您使用 Simon Jensen 的答案来退出线程并使用 QObject 作为内存策略，我认为您的情况会很好。

Answer 6

关闭工作线程的一种非常常见的方法是用一个标志对其进行标记，并让工作线程定期检查该标志。 如果被标记，它应该停止其工作流程，清理并退出。

在你的情况下有这种可能性吗？

Answer 7

工作线程应该检查是否有消息要停止。 该消息可以通过标志或事件来传递。 当收到停止消息时，线程应该退出。

对所有分配的内存使用 BOOST 安全指针。 退出时不会有内存泄漏。 曾经。

Answer 8

确保

分配的内存由智能指针拥有，可以是 C++03 的 auto_ptr、C++11 的 unique_ptr 或 Boost 的scoped_ptr，甚至是 shared_ptr （可以共享、复制和移动）。

这样，RAII 将保护您免受任何内存泄漏的影响。

使用 Boost.Thread 1.37

阅读礼貌地中断，Herb Sutter 的一篇文章，解释了中断线程的各种方法。

今天有了Boost.Thread 1.37，你可以问通过抛出异常来终止的线程。 在 Boost 中，它是 boost::thread_interrupted 异常，它将从任何 中断点。

因此，您不需要处理某种消息循环，或验证某些全局/共享数据。 主线程通过异常要求工作线程停止，一旦工作线程到达中断点，就会抛出异常。 前面描述的 RAII 机制将确保正确释放所有分配的数据。

假设您有一些将在线程中调用的伪代码。 它可能类似于一个函数，它可能会分配内存，另一个函数会在循环内进行大量计算：

Object * allocateSomeObject()
{
   Object * o = NULL ;

   if(/*something*/)
   {
      // Etc.
      o = new Object() ;
      // Etc.
   }

   return o ; // o can be NULL
}

void doSomethingLengthy()
{
   for(int i = 0; i < 1000; ++i)
   {
      // Etc.
      for(int j = 0; j < 1000; ++j)
      {
         // Etc.
         // transfert of ownership
         Object * o = allocateSomeObject() ;
         // Etc.
         delete o ;
      }
      // Etc.
   }
}

上面的代码不安全，如果不采取步骤来确保在任何情况下，无论中断模式如何，都会泄漏在所有时刻，内存都将由 C++ 对象（通常是智能指针）拥有。

可以通过这种方式进行修改，使代码既可中断又保证内存安全：

boost::shared_ptr<Object> allocateSomeObject()
{
   boost::shared_ptr<Object> o ;

   if(/*something*/)
   {
      // Etc.
      boost::this_thread::interruption_point() ;
      // Etc.
      o = new Object() ;
      // Etc.
      boost::this_thread::interruption_point() ;
      // Etc.
   }

   return o ; // o can be "NULL"
}

void doSomethingLengthy()
{
   for(int i = 0; i < 1000; ++i)
   {
      // Etc.
      for(int j = 0; j < 1000; ++j)
      {
         // Etc.
         // transfert of ownership
         boost::shared_ptr<Object> o = allocateSomeObject() ;
         // Etc.
         boost::this_thread::interruption_point() ;
         // Etc.
      }

      // Etc.
      boost::this_thread::interruption_point() ;
      // Etc.
   }
}

void mainThread(boost::thread & worker_thread)
{
   // etc.
   if(/* some condition */)
   {
      worker_thread.interrupt() ;
   }
}

不使用 Boost？

如果你不使用Boost，那么你可以模拟这个。 如果线程应该被中断，则将一些线程存储类似布尔的变量设置为“true”。 添加检查此变量的函数，然后如果为 true，则抛出特定异常。 让线程的“根”捕获此异常以使其正确结束。

免责声明

我现在无法访问 Boost 1.37，因此无法测试以前的代码，但想法是存在的。 我将尽快对此进行测试，并最终发布更完整/正确/可编译的代码。