单线程时不会发生多线程时指针数组的奇数内存泄漏

Question

花了一整天的调试后,我注意到在调用以下函数时总会发生内存泄漏:

void merge(TContainer<T> List2)
{

    TContainer<T> temp(this->Size);

    for (int i = 0; i < this->Size; i++)
    {
        temp.Interface[i] = this->Interface[i];
    }

    this->Interface = new T[Size + List2.size()];
    Size = Size + List2.size();


    for(int i = 0; i < List2.size(); i++)
    {
        Interface[i] = List2[i];
    }

    for(int i = List2.size(); i < Size; i++)
    {
        Interface[i] = temp[i];
    };
    delete[] temp.Interface;
}

在代码中:

    TContainer_Short<unsigned short> Temp = TContainer_Short<unsigned short>(0);
    for(int i = (ToUpdate.size() - 1); i >= 0; i--)
    {
        UpdateInUse = true;
        ToUpdate[i].Ad.push_back(AdQueue[i].Indirect[0].Address);
        auto Entity = ToUpdate[i];
        UpdateInUse = false;
        float HighestScore = 0;
        int Index = 0;
        //Go through all the advertisements on their queue
        //Make sure our last index is always the next plot point in our story.

        for(int j = 0; j < ToUpdate[i].Ad.size(); j++)
        {
            AdvertisementBase Ad = *World::get()->getTemplateAd(Entity.Ad[j]);

            float temp = returnScore(Entity.Index, Ad);
            //If its higher than our current score, set i to this index
            if(temp > HighestScore)
                Index = j;
        }
        //Index is last pos when we're currently continuing our plot queue. We haven't changed our mind about what advertisement we want

        if(Index !=(Entity.Ad.size() - 1))
        {

            AdvertisementBase *Ad = World::get()->getTemplateAd(Entity.Ad[Index]);
            this->reduceAdChain(Entity.Index, Ad);

        }

        else
        {
            //Makes sure that the entity is on track for the next goal that it had already determined
           plan(Entity.Index,AdQueue.Interface[Entity.Index].Indirect[0].Address);
        }
        Temp.push_back(Entity.Index);
        ToUpdate.pop_back();

    }
    if(!ExecutingInUse)
    {
        ExecutingInUse = true;
        Executing.merge(Temp);
        ExecutingInUse = false;
    }
    delete[] Temp.Interface;
}

但是,我似乎无法弄清楚为什么它只在有多个线程时才会发生.数组本身一次只能被一个线程引用(Atomic),所以它应该不是问题.

删除Executing :: merge引用会使内存泄漏消失,并且在单线程方案中肯定会显着提高性能.

更奇怪的是,合并用于其他地方:

void reduceAdChain(unsigned short Index, TContainer<AdvertisementReference> Ads)
{
    AdQueue[Index].Indirect.merge(Ads);
}

并且没有创建内存泄漏,即使reduceAdChain比Executing :: merge更频繁地被调用.并且删除此区域中的合并,即使创建也没有明显的性能提升

A)reduceAdChain用于合并的数组平均大小是传递给Executing :: merge的数组的3倍大小

和

B)reduceAdChain的总长度几乎是Executing长度的5倍.

但是,执行会在每次迭代结束时清除.

这是我在多线程环境中遇到过的最奇怪的事情之一.

使用Executing的地方:

        if(!m_simulated_entities[i]->ExecutingInUse)
        {
            for (int j = 0; j < m_simulated_entities[i]->Executing.size(); )
            {
                // Retrieve Tag Data and Update Constants
                m_simulated_entities[i]->ExecutingInUse = true;
                ExecutingIndex = m_simulated_entities[i]->Executing[j];
                m_simulated_entities[i]->ExecutingInUse = false;


                TagIndex = m_simulated_entities[i]->TagIndicesPerEntity[ExecutingIndex];
                now = std::chrono::system_clock::now();
                time_now = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

                if (m_simulated_entities[i]->Timing[m_simulated_entities[i]->Executing[j]].TimeConstant == 0)
                {
                    //Make sure all of our new attribute values still allow this entity to live
                    if(!m_simulated_entities[i]->updateTick(ExecutingIndex))
                        m_simulated_entities[i]->removeInstance(ExecutingIndex);
                    else
                    {
                        //Compute our new transfer constant
                        m_simulated_entities[i]->prepare(ExecutingIndex);
                        //Update the tagging system
                        m_simulated_entities[i]->updateTags(ExecutingIndex);
                        //Search for new decisions
                        m_simulated_entities[i]->ToSearch.push_back(ExecutingIndex);
                    }
                    //Remove the index from execution
                    m_simulated_entities[i]->ExecutingInUse = true;
                    m_simulated_entities[i]->Executing.Remove(j);
                    m_simulated_entities[i]->ExecutingInUse = false;
                }

                else if (time_now - m_simulated_entities[i]->Timing[ExecutingIndex].LastUpdateTime > updateConstants[TagIndex])
                {
                    m_simulated_entities[i]->Timing[ExecutingIndex].TimeConstant--;
                    m_simulated_entities[i]->Timing[ExecutingIndex].LastUpdateTime = time_now;
                    j++;
                }
            }
        }

对于测试,updateTick被禁用并且将始终返回true,因为允许该函数正确执行会使查找内存泄漏变得更加困难.

Answer 1

在函数合并中:

 this->Interface = new T[Size + List2.size()];

你应该检查指针 this->Interface是否是NULL,如果不是,它应该先被释放.否则,如果多次调用函数merge,它将泄漏.

所以代码将是:

if (this->Interface != NULL)
   delete[]  this->Interface;
this->Interface = new T[Size + List2.size()];