Cocos2d-x学习笔记（十四）CCAutoreleasePool具体解释

原创文章，转载请注明出处：http://blog.csdn.net/sfh366958228/article/details/38964637

前言

之前学了那么多的内容。差点儿全部的控件都要涉及内存管理类CCAutoreleasePool。所以这一次的学习笔记，我们一起来看看CCAutoreleasePool，先从CCObject的autorelease方法入手。

CCObject::autorelease

CCObject* CCObject::autorelease(void)
{
// 将当前对象加入到内存池中
CCPoolManager::sharedPoolManager()->addObject(this);

// 将当前对象设置为已被内存池管理
m_bManaged = true;
return this;
}

autoRelease类并不复杂。由代码中的凝视能够看出主要还是CCPoolManager的操作，而这部分内容被写在了CCAutoreleasePool中，让我们一起看看吧。

CCAutoreleasePool.h

class CC_DLL CCAutoreleasePool : public CCObject
{
// 保存全部加入到释放池中的对象。注意CCArray内部是通过将对象retain 然后存储起来的，应用计数会添加1
CCArray* m_pManagedObjectArray;
public:
CCAutoreleasePool(void);
~CCAutoreleasePool(void);

// 将对象加入到自己主动释放池
void addObject(CCObject *pObject);

// 将对象从自己主动释放池中移除
void removeObject(CCObject *pObject);

// 将自己主动释放池中的对象释放掉
void clear();
};

class CC_DLL CCPoolManager
{
// 用于存放自己主动释放池的队列
CCArray* m_pReleasePoolStack;

// 当前的自己主动释放池，指向自己主动释放池队列的末尾节点
CCAutoreleasePool* m_pCurReleasePool;

// 获取当前的自己主动释放池
CCAutoreleasePool* getCurReleasePool();
public:
CCPoolManager();
~CCPoolManager();

// 清空全部的自己主动释放池
void finalize();

// 添加一个自己主动释放池
void push();

// 移除一个自己主动释放池，即移除当前自己主动释放池
void pop();

// 将对象从当前的自己主动释放池中移除
void removeObject(CCObject* pObject);

// 将对象加入至当前的自己主动释放池中
void addObject(CCObject* pObject);

// 获取自己主动释放池管理者，单例模式
static CCPoolManager* sharedPoolManager();

// 清理当前内存管理者。释放当中的自己主动释放池以及自己主动释放池中的全部对象
static void purgePoolManager();

friend class CCAutoreleasePool;
};

CCAutoreleasePool.cpp

// 静态成员变量。存储整个程序中使用的CCPoolManager对象
static CCPoolManager* s_pPoolManager = NULL;

CCAutoreleasePool::CCAutoreleasePool(void)
{
//初始化队列，用以保存加入到池中的对象
m_pManagedObjectArray = new CCArray();
m_pManagedObjectArray->init();
}

CCAutoreleasePool::~CCAutoreleasePool(void)
{
CC_SAFE_DELETE(m_pManagedObjectArray);
}

// 将对象加入到自己主动释放池中
void CCAutoreleasePool::addObject(CCObject* pObject)
{
// 将对象retain 保存到队列中
m_pManagedObjectArray->addObject(pObject);

// 确保此时对象的应用计数最少是2
CCAssert(pObject->m_uReference > 1, "reference count should be greater than 1");

// 调用对象的release方法，将引用计数减1
pObject->relearese();
}

void CCAutoreleasePool::removeObject(CCObject* pObject)
{
// 从自己主动释放池中移除对象，使该对象不被自己主动释放池管理，当然也不会自己主动释放，第二个參数为false，，由于addObject被没有使引用计数添加，全部这里也不能使应用计数有变化
m_pManagedObjectArray->removeObject(pObject, false);
}

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_bManaged = false;
//(*it)->release();
//delete (*it);
#ifdef _DEBUG
nIndex--;
#endif
}
// 移除全部的在队列中的对象。依次调用全部对象的release方法
m_pManagedObjectArray->removeAllObjects();
}
}

//--------------------------------------------------------------------
//
// CCPoolManager
//
//--------------------------------------------------------------------

// 获取自己主动释放池管理者
CCPoolManager* CCPoolManager::sharedPoolManager()
{
if (s_pPoolManager == NULL)
{
s_pPoolManager = new CCPoolManager();
}
return s_pPoolManager;
}

void CCPoolManager::purgePoolManager()
{
CC_SAFE_DELETE(s_pPoolManager);
}

CCPoolManager::CCPoolManager()
{
// 初始化自己主动释放池队列
m_pReleasePoolStack = new CCArray();
m_pReleasePoolStack->init();

// 当前的自己主动释放池为空
m_pCurReleasePool = 0;
}

CCPoolManager::~CCPoolManager()
{
// 释放全部的自己主动释放池
finalize();

// we only release the last autorelease pool here
m_pCurReleasePool = 0;
m_pReleasePoolStack->removeObjectAtIndex(0);

CC_SAFE_DELETE(m_pReleasePoolStack);
}

void CCPoolManager::finalize()
{
// 清空自己主动释放池队列中的全部自己主动释放池
if(m_pReleasePoolStack->count() > 0)
{
//CCAutoreleasePool* pReleasePool;
CCObject* pObj = NULL;
CCARRAY_FOREACH(m_pReleasePoolStack, pObj)
{
if(!pObj)
break;
CCAutoreleasePool* pPool = (CCAutoreleasePool*)pObj;
pPool->clear();
}
}
}

void CCPoolManager::push()
{
// 向自己主动释放池队列中加入一个新的自己主动释放池。将新加入的自己主动释放池作为当前的
// 自己主动释放池使用
CCAutoreleasePool* pPool = new CCAutoreleasePool();       //ref = 1
m_pCurReleasePool = pPool;

m_pReleasePoolStack->addObject(pPool);                   //ref = 2

pPool->release();                                       //ref = 1
}

void CCPoolManager::pop()
{
// 清理自己主动释放池队列，仅仅剩下队列中的第一个自己主动释放池
// 剩下的这个自己主动释放池中的对象也要清理掉
// 这个函数便是自己主动释放池管理者，实现自己主动释放池内对象的实现了
if (! m_pCurReleasePool)
{
return;
}

int nCount = m_pReleasePoolStack->count();

// 清理当前的自己主动释放池
m_pCurReleasePool->clear();

if(nCount > 1)
{
// 假设自己主动释放池队列中有超过一个自己主动释放池
// 将末端的自己主动释放池清理并移除
m_pReleasePoolStack->removeObjectAtIndex(nCount-1);
m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2);
}
}

void CCPoolManager::removeObject(CCObject* pObject)
{
// 从当前的自己主动释放池中移除对象
CCAssert(m_pCurReleasePool, "current auto release pool should not be null");

m_pCurReleasePool->removeObject(pObject);
}

void CCPoolManager::addObject(CCObject* pObject)
{
// 将对象加入到当前的自己主动释放池中
getCurReleasePool()->addObject(pObject);
}

CCAutoreleasePool* CCPoolManager::getCurReleasePool()
{

// 获取当前的自己主动释放池
// 假设当前的自己主动释放池为空。说明自己主动释放池队列中也为空
// 通过push方法。加入新的自己主动释放池
if(!m_pCurReleasePool)
{
push();
}

CCAssert(m_pCurReleasePool, "current auto release pool should not be null");

return m_pCurReleasePool;
}

自己主动释放池管理者通过pop方法，将当前自己主动释放池中的全部对象调用release方法进行释放，pop方法是什么时候在什么地方进行调用的呢？事实上答案就在我们之前看到过的mainloop方法中：

void CCDisplayLinkDirector::mainLoop(void)
{
if (m_bPurgeDirecotorInNextLoop)
{
m_bPurgeDirecotorInNextLoop = false;
purgeDirector();
}
else if (! m_bInvalid)
{
// 绘制场景
drawScene();

// 释放自己主动释放池
CCPoolManager::sharedPoolManager()->pop();
}
}

在每一帧绘制完毕之后，当前的自己主动释放池将会被清理，全部调用了autorelease操作的对象都会被调用release方法。降低其引用计数。假设我们创建的对象调用了autorelease，那么在稍后帧绘制之后。自己主动释放池被清理的时候此对象的引用计数将被减1，此对象假设没有在其它地方被retain。那么它将会被释放掉。

在对象的使用上，为保证对象能被正确的释放，须要时刻知道此对象的引用计数为多少，可是非常多时候能做到这点非常难。除非对全部的接口都非常了解，知道当中是否对当前对象做了retain操作或者release操作。假设做不到这点，能够依照cocos2d-x框架中这种原则去做

1、作为參数传进来的对象。假设你要长期的使用或者管理它，请 retain，不用的时候记得release

2、作为參数传进来的对象，他不是你创建或者retain的，假设你不确定他从哪里来，外面是否知道你会release掉他。请别随便调用release

3、假设你撇开自己主动释放池，new了一个对象而不调用autorelease，在不使用的时候直接将对象delete掉。这种做法是非常不安全的。除非你创建的对象真的仅仅有你在使用而没有被其它对象retain。但并不是代表你不能自己new和delete管理对象，因时而异。

4、创建一个新的对象。调用了对象的autorelease方法，假设想长期的使用他，请使用retain方法（包含addChild到自身，addObject到某个CCArray中），清除时使用release方法（removeChild、CCArray的removeObject等）

參考资料

1）cocos2d-x学习笔记内存管理之autorelease http://hi.baidu.com/357802636/item/7bb3e71a7838efd6be904200