cocos2dx內存管理

今天想探索一下cocos2dx的內存管理，咱們就先從CCObject開始吧

class CC_DLL CCObject : public CCCopying
{
public:
    // object id, CCScriptSupport need public m_uID
    unsigned int        m_uID;
    // Lua reference id
    int                 m_nLuaID;
protected:
    // count of references
    unsigned int        m_uReference;
    // count of autorelease
    unsigned int        m_uAutoReleaseCount;
public:
    CCObject(void);
    virtual ~CCObject(void);
    
    void release(void);
    void retain(void);
    CCObject* autorelease(void);
    CCObject* copy(void);
    bool isSingleReference(void);
    unsigned int retainCount(void);
    virtual bool isEqual(const CCObject* pObject);

    virtual void update(float dt) {CC_UNUSED_PARAM(dt);};
    
    friend class CCAutoreleasePool;
    
    unsigned int getAutoReleaseCount();
};

以上是CCObject的定義，能夠看出CCObject主要有兩個保護成員：m_uReference和m_uAutoReleaseCount，這個兩個成員到底有什麼用呢？讓咱們一探究竟，首先咱們來看一下CCObject的構造函數：

CCObject::CCObject(void)
: m_nLuaID(0)
, m_uReference(1) // when the object is created, the reference count of it is 1
, m_uAutoReleaseCount(0)
{
    static unsigned int uObjectCount = 0;

    m_uID = ++uObjectCount;
}

從構造函數我麼能夠看出m_uReference初始化爲1，m_uAutoReleaseCount初始化爲0，另外CCObject維護了一個靜態無符號整型變量：uObjectCount來記錄CCObject實例的總數目。而後咱們來看一下release()和retain()函數：

 

void CCObject::release(void)
{
    if (m_uReference == 0) {//modify by yangm
        CCLOG("CCObject::release reference count should greater than 0");
        return;
    }
    CCAssert(m_uReference > 0, "reference count should greater than 0");
    --m_uReference;
    
    if (m_uReference == 0)
    {
        delete this;
    }
}

由release()函數能夠看到每執行一次release()，m_uReference自減一，只有當m_uReference爲零時CCObject對象纔會被釋放；

void CCObject::retain(void)
{
    if (m_uReference == 0) {//modify by yangm
        CCLOG("CCObject::retain reference count should greater than 0,m_uReference=%d",m_uReference);
        return;
    }
    CCAssert(m_uReference > 0, "reference count should greater than 0");

    ++m_uReference;
}

retain()函數和release()函數功能正好相反，每調用一次retain()，m_uReference會自增一；接下來咱們再來看看autorelease()函數：

CCObject* CCObject::autorelease(void)
{
    CCPoolManager::sharedPoolManager()->addObject(this);
    return this;
}
void CCPoolManager::addObject(CCObject* pObject)
{
    getCurReleasePool()->addObject(pObject);  //獲取棧頂得CCAutoreleasePool實例，並將CCObject加入到CCAutoreleasePool中
}

此處涉及到一個CCPoolManager類，該類內部有一個CCAutoreleasePool類型的棧，而CCPoolManager又是什麼呢？其實CCPoolManager就是一個CCArray一個可增加的數組，咱們來看看他得addObject(CCObject* pObject)函數：

 

void CCAutoreleasePool::addObject(CCObject* pObject)
{
    m_pManagedObjectArray->addObject(pObject);  //向CCArray中添加CCObject實例

    CCAssert(pObject->m_uReference > 1, "reference count should be greater than 1");
    ++(pObject->m_uAutoReleaseCount);   //CCObject的m_uAutoReleaseCount自增一
    pObject->release(); // no ref count, in this case autorelease pool added.  
}

在調試的時候咱們會發現CCObject在release()時他的m_uReference爲2，也就避免了被釋放，其實該對象實例在添加到自動釋放池（CCAutoreleasePool）的時候retain了一下；咱們來驗證一下，來看看下面的幾個函數：

void CCArray::addObject(CCObject* object)
{
    ccArrayAppendObjectWithResize(data, object);
}
/** Appends an object. Capacity of arr is increased if needed. */
void ccArrayAppendObjectWithResize(ccArray *arr, CCObject* object)
{
    ccArrayEnsureExtraCapacity(arr, 1);
    ccArrayAppendObject(arr, object);
}

/** Appends an object. Behavior undefined if array doesn't have enough capacity. */
void ccArrayAppendObject(ccArray *arr, CCObject* object)
{
    CCAssert(object != NULL, "Invalid parameter!");
    object->retain();                           //此處果真retain了一下
    arr->arr[arr->num] = object;
    arr->num++;
}

接下來咱們來看一下cocos2dx如何銷燬那些無效的對象實例，如下是整個程序的主循環：

 

void CCDisplayLinkDirector::mainLoop(void)
{
    if (m_bPurgeDirecotorInNextLoop)
    {
        m_bPurgeDirecotorInNextLoop = false;
        purgeDirector();
    }
    else if (! m_bInvalid)
     {
         drawScene();
     
         // release the objects
         CCPoolManager::sharedPoolManager()->pop();        
     }
}

由上面函數可知coco2dx在每一幀的幀尾會調用自動釋放內存池的管理者—CCPoolManager的pop()函數，咱們來看看該函數主要作了哪些工做？

 

void CCPoolManager::pop()
{
    if (! m_pCurReleasePool)
    {
        return;
    }

     int nCount = m_pReleasePoolStack->count();

    m_pCurReleasePool->clear();
 
      if(nCount > 1)
      {
        m_pReleasePoolStack->removeObjectAtIndex(nCount-1);

//         if(nCount > 1)
//         {
//             m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2);
//             return;
//         }
        m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2);
    }

    /*m_pCurReleasePool = NULL;*/
}

主要作的就兩點：一、清除當前的自動釋放池，二、更新當前自動釋放池指針；咱們來看看他是如何clear？

 

void CCAutoreleasePool::clear()
{
    if(m_pManagedObjectArray->count() > 0)
    {
        //CCAutoreleasePool* pReleasePool;
#ifdef _DEBUG
        int nIndex = m_pManagedObjectArray->count() - 1;
#endif

        CCObject* pObj = NULL;
        CCARRAY_FOREACH_REVERSE(m_pManagedObjectArray, pObj)
        {
            if(!pObj)
                break;

            --(pObj->m_uAutoReleaseCount);
            
            if( (int)(pObj->m_uAutoReleaseCount)<0 ){
                pObj->m_uAutoReleaseCount = 0;
            }
            //(*it)->release();
            //delete (*it);
#ifdef _DEBUG
            nIndex--;
#endif
        }

        m_pManagedObjectArray->removeAllObjects();
    }
}

以上函數主要作的工做是：一、將內部的全部元素的自動釋放引用m_uAutoReleaseCount減一。二、清除內部的全部元素。看到這裏我很詫異：爲何要清除全部的元素呢？難道不是清除那些無效的對象實例嗎？緊接着看下面的函數看他如何removeAllObjects。

 

void CCArray::removeAllObjects()
{
    ccArrayRemoveAllObjects(data);
}

void ccArrayRemoveAllObjects(ccArray *arr)
{
    while( arr->num > 0 )
    {
        (arr->arr[—arr->num])->release();  //注意此處的—arr->num
    }
}

以上函數其實就是將數組內部的全部元素release一下，並將元素個數減爲0。到這裏整個對象建立—添加到自動釋放池—幀尾的釋放的過程就完了，我一開始非常納悶，假如我有定義了一個類以下：

class A  : public CCNode
{
private:
    CCSprite* m_pSprite1;
    CCSprite* m_pSprite2;
public:
    CREATE_FUNC(A);
    virtual bool init();
};
bool A::init()
{
    m_pSprite1 = CCSprite::create(「1.png」);   //建立精靈1
    m_pSprite2 = CCSprite::create(「2.png」);  //建立精靈2
    this->addChild(m_pSprite);  //只將精靈1添加到父節點
}

實際上到下一幀的時候，m_pSprite2所指向的內存已經無效，m_Sprite1仍然有效。上面的過程是如何作到的呢？只有這種狀況才能解釋：m_pSprite1和m_pSprite2在create的時候加入到了自動釋放池被監視，而m_pSprite1再加入到父節點時retain了一下，纔不會在幀尾release的時候被釋放掉。咱們來驗證一下CCNode::addChild(…)(參數就不寫了):

 

void CCNode::addChild(CCNode *child, int zOrder, int tag)
{    
    CCAssert( child != NULL, "Argument must be non-nil");
    CCAssert( child->m_pParent == NULL, "child already added. It can't be added again");

    if( ! m_pChildren )
    {
        this->childrenAlloc();
    }

    this->insertChild(child, zOrder);

    child->m_nTag = tag;

    child->setParent(this);
    child->setOrderOfArrival(s_globalOrderOfArrival++);

    if( m_bRunning )
    {
        child->onEnter();
        child->onEnterTransitionDidFinish();
    }
}

發現沒有retain,繼續看insertChild函數：

void CCNode::insertChild(CCNode* child, int z)
{
    m_bReorderChildDirty = true;
    ccArrayAppendObjectWithResize(m_pChildren->data, child);
    child->_setZOrder(z);
}

發現也沒有retain，繼續看ccArrayAppendObjectWithResize函數

 

void ccArrayAppendObjectWithResize(ccArray *arr, CCObject* object)
{
    ccArrayEnsureExtraCapacity(arr, 1);
    ccArrayAppendObject(arr, object);
}

任然沒有retain，繼續看ccArrayAppendObject函數

 

void ccArrayAppendObject(ccArray *arr, CCObject* object)
{
    CCAssert(object != NULL, "Invalid parameter!");
    object->retain();
    arr->arr[arr->num] = object;
    arr->num++;
}

終於發現了retain。

總結：當一個CCObject實例被建立：

一、若被autorelease()，那麼在當前幀的幀尾會被release()一次（注意僅僅一次，之後就會被移除監視），若以前加入到了父節點中那麼幀尾的release()時會避免釋放，反之則會被無情的釋放掉。若是沒有加入到父節點又想一想擁有該對象，那麼須要本身retain();

二、若沒有autorelease(),那麼這個實例就須要本身來管理。