在单个 slot_type 上使用多个 boost::connect 导致内存泄漏

Question

当我尝试将多个信号连接到单个 slot_type 时，我正在使用 boost::signals 并泄漏内存。我在各个论坛上看到过同样的泄漏报告，但找不到任何提到执行此操作的正确方法或任何解决方法的内容。

我想做的事情：

我试图将 boost::bind() 的结果传递到函数中。在此函数中，我想将多个信号连接到该结果。第一个连接工作正常，但第一个连接之后的每个连接都会泄漏句柄。

以下是一些示例代码：

typedef boost::signal0<void> LeakSignalType;

class CalledClass
{
   /* ... */
   void connectToSlots(LeakSignalType::slot_type &aSlot)
   {
        LeakSignalType *sig;
        std::list<LeakSignalType*> sigList;
        std::list<LeakSignalType*>::iterator sigIter;

        for(int i = 0; i < 50; i++)
        {
            /*Connect signals to the passed slot */
            sig = new LeakSignalType;
            sig->connect(aSlot);
            sigList.push_back(sig);
        }
        for(sigIter = sigList.begin(); sigIter != sigList.end(); sigIter++)
        {
            /* Undo everything we just did */
            delete *sigIter;
        }
        sigList.clear();
        /*Everything should be cleaned up now */
   }
   /* ... */
}

class CallingClass : public boost::signals::trackable
{
   CalledClass calledInstance;
   /* ... */
   void boundFunction(int i)
   {
   /*Do Something*/
   }

   void connectSignals()
   {
       calledInstance.connectToSlots(boost::bind( &CallingClass::boundFunction, this, 1));
   }
   /* ... */
};

现在调用 CallingClass::connectSignals()。

我预计对 connectToSlots 的调用会将 50 个信号连接到单个插槽，然后断开连接并清理所有这些信号。实际发生的情况是，1 个信号完全清理，然后其余 49 个信号部分清理，但泄漏了一些内存。

将插槽传递到函数中以供多次使用的正确方法是什么？任何帮助将不胜感激。

谢谢， 克里斯

Answer 1

我很确定这是一个错误。如果您将其折叠为一个小示例，例如：

void boundFunction(int) { }
typedef boost::signal0<void> LeakSignalType;
LeakSignalType::slot_type aSlot = boost::bind(&::boundFunction, 1);
LeakSignalType sig1, sig2;
sig1.connect(aSlot);
sig2.connect(aSlot);

并跟踪分配，您会发现在行分配了一个对象（boost::signals::detail::signal_base_impl::iterator） boost/lib/signals/src/signal_base.cpp 的 75 部分未释放。

// Allocate storage for an iterator that will hold the point of
// insertion of the slot into the list. This is used to later remove
// the slot when it is disconnected.
std::auto_ptr<iterator> saved_iter(new iterator);

在第一个 connect 上，此迭代器附加到一个新的连接对象，其中 signal_data 为 NULL：

data->watch_bound_objects.get_connection()->signal_data =
  saved_iter.release();

但是，在第二个 connect 上，相同连接对象被复用，同一行盲目覆盖原来的指针值。第二个对象已清理，但第一个对象尚未清理。

作为验证，signal_base_impl::slot_disconnected 中的断点（唯一清理 signal_data 的地方）仅触发一次。

我在 1.39.0 中找到了这个，但看起来在 1.40.0 中也是一样的。

您可以修改 boost::signals::detail::signal_base_impl::connect_slot 来清理它在现有连接的 signal_data 字段中找到的任何先前的迭代器值，如果您我们很乐意进行这样的更改并运行 Boost 的自定义构建。

最好确保您只设置固定次数，并忍受一些小的内存泄漏，您知道这些泄漏不会随着时间的推移而增加。

更新：

我本来打算将其提交给 Boost bug 跟踪器，但它已经在那里了。然而，这是一个小得多的测试用例。

https://svn.boost.org/trac/boost/ticket/738

3年前开业，未分配任何里程碑:-[

Answer 2

为了供其他人参考，我很幸运地维护了自己的 signal_data 副本，并在删除信号之前将其删除。不知道有什么副作用，YMMV。

像这样的东西：

typedef boost::signal0<void> LeakSignalType;
struct LeakSignalStruct
{
    LeakSignalType  signal;
    /* A pointer to keep track of the pointer Boost loses */
    boost::signals::detail::named_slot_map_iterator *signal_data;
};

class CalledClass
{
   /* ... */
   void connectToSlots(LeakSignalType::slot_type &aSlot)
   {
        LeakSignalStruct *sig;
        std::list<LeakSignalStruct*> sigList;
        std::list<LeakSignalStruct*>::iterator sigIter;

        for(int i = 0; i < 50; i++)
        {
            /*Connect signals to the passed slot */
            sig = new LeakSignalStruct;
            sig->connect(aSlot);
            /* Make a backup of the reference that Boost will lose */
            sig->signal_data = (boost::signals::detail::named_slot_map_iterator*)connection.get_connection()->signal_data;
            sigList.push_back(sig);
        }

        /* Boost remembers the last signal_data and will delete it itself,
           so we better lose our reference to avoid double-delete */
        sig->signal_data = NULL;

        for(sigIter = sigList.begin(); sigIter != sigList.end(); sigIter++)
        {
            /* Undo everything we just did */
            /* Boost lost this reference, so we delete it ourselves */
            delete (*sigIter)->signal_data;
            delete *sigIter;
        }
        sigList.clear();
        /*Everything should be cleaned up now */
   }
   /* ... */
};

class CallingClass : public boost::signals::trackable
{
   CalledClass calledInstance;
   /* ... */
   void boundFunction(int i)
   {
   /*Do Something*/
   }

   void connectSignals()
   {
       calledInstance.connectToSlots(boost::bind( &CallingClass::boundFunction, this, 1));
   }
   /* ... */
};