cocos2d-x内存管理源码

Cocos2d-x移植自Objective C的Cocos2d，其内存管理机制也源自OC。对于有OC编程经验的开发者而言，Cocos2d-x的内存管理应该不难理解；但对于未接触过OC的C++开发者来说，直接查看Cocos2d-x源代码是最直接有效的学习方式。

Node类

Node类是Cocos2d-x中非常重要的基类，像常用的Scene、Layer、MenuItem等类都继承自Node。

Node的创建接口

Node的创建通过以下静态接口实现，该函数返回一个Node的静态对象指针：

/**
* Allocates and initializes a node.
* @return A initialized node which is marked as “autorelease”.
*/
/**
* 分配空间并初始化Node
* 返回一个被初始化过且是autorelease的Node对象
*/
static Node * create();

create函数的实现

该函数采用二段式创建方式：首先使用new运算符在堆上开辟空间并进行简单初始化，若new返回合法地址（Cocos2d-x未采用C++的异常处理机制），则调用init函数进行Node成员的实际初始化。只有当这两步都成功时，才将创建的指针设为autorelease并返回。

Node * Node::create()
{
Node * ret = new Node();
if (ret && ret->init())
{
ret->autorelease();
}
else
{
CC_SAFE_DELETE(ret);
}
return ret;
}

对于创建失败的情况，Cocos2d-x使用以下宏确保指针被delete并设为nullptr：

#define CC_SAFE_DELETE(p)
do { delete (p); (p) = nullptr; } while(0)

由于这种二段式的create函数在Cocos2d-x中很常用，因此使用CREATE_FUNC宏来表示该函数，供继承Node的子类使用：

/**
* define a create function for a specific type, such as Layer
* @param \__TYPE__  class type to add create(), such as Layer
*/
#define CREATE_FUNC(__TYPE__) \
static __TYPE__* create() \
{ \
__TYPE__ *pRet = new __TYPE__(); \
if (pRet && pRet->init()) \
{ \
pRet->autorelease(); \
return pRet; \
} \
else \
{ \
delete pRet; \
pRet = NULL; \
return NULL; \
} \
}

继承Node的子类（如ExampleLayer）只需在类声明中加入CREATE_FUNC(类名)（如CREATE_FUNC(ExampleLayer)），并重写init函数即可。

Ref类

在Cocos2d-x中，Node类的父类是Ref类，前面提到的autorelease方法就来自这个父类。

Ref类的声明

为突出重点，忽略脚本绑定的情况：

class CC_DLL Ref
{
public:
/**
* Retains the ownership.
*
* This increases the Ref’s reference count.
*
* @see release, autorelease
* @js NA
*/
/**
* 拿到所有权
* 这会增加引用计数
*/
void retain();

/**
* Releases the ownership immediately.
*
* This decrements the Ref’s reference count.
*
* If the reference count reaches 0 after the descrement, this Ref is
* destructed.
*
* @see retain, autorelease
* @js NA
*/
/**
* 立即释放所有权
* 这会减少引用计数
* 如果更新后的引用计数为0，该Ref对象会被销毁
*/
void release();

/**
* Releases the ownership sometime soon automatically.
*
* This descrements the Ref’s reference count at the end of current
* autorelease pool block.
*
* If the reference count reaches 0 after the descrement, this Ref is
* destructed.
*
* @returns The Ref itself.
*
* @see AutoreleasePool, retain, release
* @js NA
* @lua NA
*/
/**
* 自动释放所有权
* 这会减少引用计数
*
* This descrements the Ref’s reference count at the end of current
* autorelease pool block.
* 如果更新后的引用计数为0，该Ref对象会被销毁
* If the reference count reaches 0 after the descrement, this Ref is
* destructed.
*/
Ref* autorelease();

/**
* Returns the Ref’s current reference count.
*
* @returns The Ref’s reference count.
* @js NA
*/
/**
* 返回该Ref对象的引用计数
*/
unsigned int getReferenceCount() const;

protected:
/**
* Constructor
*
* The Ref’s reference count is 1 after construction.
* @js NA
*/
/**
* 构造函数
* 初始引用计数为1
*/
Ref();

public:
/**
* @js NA
* @lua NA
*/
virtual ~Ref();

protected:
/**
* 采用引用计数(reference counting)
* _referenceCount就是计数值
*/
// count of references
unsigned int _referenceCount;

friend class AutoreleasePool;

// Memory leak diagnostic data (only included when CC_USE_MEM_LEAK_DETECTION is defined and its value isn’t zero)
// 以下函数用于开启内存泄露检测时打印出泄露信息
#if CC_USE_MEM_LEAK_DETECTION
public:
static void printLeaks();
#endif
};

从上述代码可以初步了解到：Ref采用引用计数的方法管理指针所指向的对象，初始创建时计数为1，计数变为0时对象被析构；retain方法增加计数并获取所有权，release方法减少计数；autorelease将所有权交给友类AutoreleasePool，由其决定何时减少计数。

Ref类的实现

#if CC_USE_MEM_LEAK_DETECTION
static void trackRef(Ref* ref);
static void untrackRef(Ref* ref);
#endif

// 在初始化列表中将计数设为1
Ref::Ref()
: _referenceCount(1) // when the Ref is created, the reference count of it is 1
{
// 假如开启内存泄露检测，则追踪该对象指针，将该对象指针放入一个列表（list）中
// 后面的代码我们很快就会看到这个list
#if CC_USE_MEM_LEAK_DETECTION
trackRef(this);
#endif
}

Ref::~Ref()
{
// 假如开启内存泄露检测且引用计数非0，则在追踪列表中找到该对象指针并删除
#if CC_USE_MEM_LEAK_DETECTION
if (_referenceCount != 0)
untrackRef(this);
#endif
}

// retain只是单纯将计数递增
void Ref::retain()
{
// CCASSERT是cocos2d-x对C++的assert所封装的宏
CCASSERT(_referenceCount > 0, "reference count should greater than 0");
++_referenceCount;
}

void Ref::release()
{
// 首先计数递减
CCASSERT(_referenceCount > 0, "reference count should greater than 0");
--_referenceCount;

// 计数为0，应当析构对象
if (_referenceCount == 0)
{
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
// 得到一个PoolManager单例的对象
// PoolManager类后面会解释
auto poolManager = PoolManager::getInstance();
// 后面会详细解释这段代码
if (!poolManager->getCurrentPool()->isClearing() && poolManager->isObjectInPools(this))
{
// 以下的注释很重要，很快会解释到
// Trigger an assert if the reference count is 0 but the Ref is still in autorelease pool.
// This happens when ‘autorelease/release’ were not used in pairs with ‘new/retain’.
//
// Wrong usage (1):
//
// auto obj = Node::create();   // Ref = 1, but it’s an autorelease Ref which means it was in the autorelease pool.
// obj->autorelease();   // Wrong: If you wish to invoke autorelease several times, you should retain `obj` first.
//
// Wrong usage (2):
//
// auto obj = Node::create();
// obj->release();   // Wrong: obj is an autorelease Ref, it will be released when clearing current pool.
//
// Correct usage (1):
//
// auto obj = Node::create();
//                     |-   new Node();     // `new` is the pair of the `autorelease` of next line
//                     |-   autorelease();  // The pair of `new Node`.
//
// obj->retain();
// obj->autorelease();  // This `autorelease` is the pair of `retain` of previous line.
//
// Correct usage (2):
//
// auto obj = Node::create();
// obj->retain();
// obj->release();   // This `release` is the pair of `retain` of previous line.
CCASSERT(false, "The reference shouldn’t be 0 because it is still in autorelease pool.");
}
#endif

// 假如开启内存泄露检测，则在追踪列表中找到该对象指针并删除
#if CC_USE_MEM_LEAK_DETECTION
untrackRef(this);
#endif

// 调用析构函数并释放空间
delete this;
}
}

// 把该对象指针交给友类AutoreleasePool（具体来说，是PoolManager单例对象所得到的当前的AutoreleasePool）来管理
Ref* Ref::autorelease()
{
PoolManager::getInstance()->getCurrentPool()->addObject(this);
return this;
}

unsigned int Ref::getReferenceCount() const
{
return _referenceCount;
}

#if CC_USE_MEM_LEAK_DETECTION
// 这里便是存放所追踪的对象指针的列表
static std::list<Ref*> __refAllocationList;

void Ref::printLeaks()
{
// Dump Ref object memory leaks
if (__refAllocationList.empty())
{
log("[memory] All Ref objects successfully cleaned up (no leaks detected).\n");
}
else
{
log("[memory] WARNING: %d Ref objects still active in memory.\n", (int)__refAllocationList.size());
// C++的range-for语法
// 打印出每个泄露内存的对象指针的类型和引用计数
for (const auto& ref : __refAllocationList)
{
CC_ASSERT(ref);
const char* type = typeid(*ref).name();
log("[memory] LEAK: Ref object ‘%s’ still active with reference count %d.\n", (type ? type : ""), ref->getReferenceCount());
}
}
}

// 将对象指针放入列表中
static void trackRef(Ref* ref)
{
CCASSERT(ref, "Invalid parameter, ref should not be null!");
// Create memory allocation record.
__refAllocationList.push_back(ref);
}

// 在列表中找到该对象指针并删除
static void untrackRef(Ref* ref)
{
auto iter = std::find(__refAllocationList.begin(), __refAllocationList.end(), ref);
if (iter == __refAllocationList.end())
{
log("[memory] CORRUPTION: Attempting to free (%s) with invalid ref tracking record.\n", typeid(*ref).name());
return;
}
__refAllocationList.erase(iter);
}
#endif // #if CC_USE_MEM_LEAK_DETECTION

这段源代码对使用者最重要的是release函数中的注释：当Ref的计数变为0时，它一定不能在AutoreleasePool中。Ref的计数为0且同时在AutoreleasePool中的错误是由new/retain和autorelease/release不对应引起的。

• autorelease缺乏对应的retain：

  auto obj = Node::create();   // 注意create函数会调用autorelease方法，因此obj已经没有该指针的所有权了
  obj->autorelease();   // obj没有所有权，因此无法再把所有权转交给AutoreleasePool，若要调用autorelease方法需要先调用retain拿到所有权
  

• release缺乏对应的retain：

  auto obj = Node::create();   // 注意create函数会调用autorelease方法，因此obj已经没有该指针的所有权了
  obj->release();   // obj没有所有权，因此无法再控制计数（所有权在AutoreleasePool），若要调用release方法需要先调用retain拿到所有权
  

  正确的用法是在create后调用autorelease或release方法前先用retain拿到所有权：

  // 前面我们分析过create函数，它会先用new operator得到对象，再调用autorelease方法
  // 这里new和autorelease对应
  auto obj = Node::create();
  |-   new Node();
  |-   autorelease();
  // 这里retain和autorelease对应，autorelease一个已经被autorelease过的对象（例如通过create函数构造的对象）必须先retain
  obj->retain();
  obj->autorelease();
  

  又如：

  auto obj = Node::create();
  // 这里retain和release对应，release一个已经被autorelease过的对象（例如通过create函数构造的对象）必须先retain
  obj->retain();
  obj->release();
  

AutoreleasePool类

现在来看Ref类的友类AutoreleasePool。

类声明

class CC_DLL AutoreleasePool
{
public:
/**
* @warn Don’t create an auto release pool in heap, create it in stack.
* @js NA
* @lua NA
*/
/**
* 警告：不要在heap上构造AutoreleasePool对象，要在stack上构造
*/
AutoreleasePool();

/**
* Create an autorelease pool with specific name. This name is useful for debugging.
*/
AutoreleasePool(const std::string &name);

/**
* @js NA
* @lua NA
*/
~AutoreleasePool();

/**
* Add a given object to this pool.
*
* The same object may be added several times to the same pool; When the
* pool is destructed, the object’s Ref::release() method will be called
* for each time it was added.
*
* @param object    The object to add to the pool.
* @js NA
* @lua NA
*/
/**
* 把指定的对象指针放到AutoreleasePool对象中
* 注意：
* 同一对象的指针可能会被多次加入到同一AutoreleasePool对象中；
* 当该AutoreleasePool对象被析构时，该对象指针被加入多少次，就得调用多少次该对象的release()函数
* 这是因为AutoreleasePool用vector而非set来存放所管理的对象指针，因此不会去重
*/
void addObject(Ref *object);

/**
* Clear the autorelease pool.
*
* Ref::release() will be called for each time the managed object is
* added to the pool.
* @js NA
* @lua NA
*/
/**
* 清空AutoreleasePool
* 每个被管理的对象指针被加入多少次，就会调用多少次release()函数
*/
void clear();

#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
/**
* Whether the pool is doing `clear` operation.
*/
bool isClearing() const { return _isClearing; };
#endif

/**
* Checks whether the pool contains the specified object.
*/
/**
* 检查AutoreleasePool对象是否管理某个对象指针
*/
bool contains(Ref* object) const;

/**
* Dump the objects that are put into autorelease pool. It is used for debugging.
*
* The result will look like:
* Object pointer address     object id     reference count
*
*/
void dump();

private:
/**
* The underlying array of object managed by the pool.
*
* Although Array retains the object once when an object is added, proper
* Ref::release() is called outside the array to make sure that the pool
* does not affect the managed object’s reference count. So an object can
* be destructed properly by calling Ref::release() even if the object
* is in the pool.
*/
/**
* AutoreleasePool对象将它所管理的对象指针放到下面的vector中
* 尽管每次有对象指针加到该vector中时，该vector实际上retain拿到了所有权，
* 但是Ref::release()会被调用来保证AutoreleasePool不会改变它所管理的对象指针
* 的引用计数。
* 所以，当某个对象指针被放到AutoreleasePool类中管理时，仍然可以通过调用
* Ref::release()函数来析构它
*/
std::vector<Ref*> _managedObjectArray;

std::string _name;

#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
/**
*  The flag for checking whether the pool is doing `clear` operation.
*/
bool _isClearing;
#endif
};

从类声明可知，AutoreleasePool类使用STL vector存放所管理的Ref对象指针。

类实现

AutoreleasePool::AutoreleasePool(): _name("")
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
, _isClearing(false)
#endif
{
_managedObjectArray.reserve(150);
// 每个新创建的AutoreleasePool对象都交由PoolManager单例对象统一管理
PoolManager::getInstance()->push(this);
}

AutoreleasePool::AutoreleasePool(const std::string &name)
: _name(name)
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
, _isClearing(false)
#endif
{
_managedObjectArray.reserve(150);
// 每个新创建的AutoreleasePool对象都交由PoolManager单例对象统一管理
PoolManager::getInstance()->push(this);
}

AutoreleasePool::~AutoreleasePool()
{
CCLOGINFO("deallocing AutoreleasePool: %p", this);
// 清空该AutoreleasePool
clear();
// 要析构的AutoreleasePool对象不再由PoolManager管理
PoolManager::getInstance()->pop();
}

// 只是单纯调用vector::push_back加入所管理的对象
void AutoreleasePool::addObject(Ref* object)
{
_managedObjectArray.push_back(object);
}

// clear函数就是AutoreleasePool调用release来管理对象的引用计数的地方
void AutoreleasePool::clear()
{
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
_isClearing = true;
#endif

// 调用每个在AutoreleasePool的对象指针的release方法
for (const auto &obj : _managedObjectArray)
{
obj->release();
}

// 清空存放管理对象的vector
_managedObjectArray.clear();

#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
_isClearing = false;
#endif
}

// 线性搜索所管理的对象指针的vector，查看所指定的Ref指针是否存在
bool AutoreleasePool::contains(Ref* object) const
{
for (const auto& obj : _managedObjectArray)
{
if (obj == object)
return true;
}
return false;
}

void AutoreleasePool::dump()
{
CCLOG("autorelease pool: %s, number of managed object %d\n", _name.c_str(), static_cast<int>(_managedObjectArray.size()));
CCLOG("%20s%20s%20s", "Object pointer", "Object id", "reference count");
for (const auto &obj : _managedObjectArray)
{
CC_UNUSED_PARAM(obj);
CCLOG("%20p%20u\n", obj, obj->getReferenceCount());
}
}

PoolManager类

在Cocos2d-x中，PoolManager类是典型的单例工厂类，即只有一个PoolManager对象。该对象有一个存放AutoreleasePool对象指针的栈，由STL vector实现。需要注意的是，Cocos2d-x的单例类都不是线程安全的，与内存管理紧密相关的PoolManager类也不例外，因此在多线程中使用Cocos2d-x的接口时，需特别注意内存管理问题。

类声明

class CC_DLL PoolManager
{
public:
/**
* @js NA
* @lua NA
*/
CC_DEPRECATED_ATTRIBUTE static PoolManager* sharedPoolManager() { return getInstance(); }

static PoolManager* getInstance();

/**
* @js NA
* @lua NA
*/
CC_DEPRECATED_ATTRIBUTE static void purgePoolManager() { destroyInstance(); }

static void destroyInstance();

/**
* Get current auto release pool, there is at least one auto release pool that created by engine.
* You can create your own auto release pool at demand, which will be put into auto releae pool stack.
*/
AutoreleasePool *getCurrentPool() const;

bool isObjectInPools(Ref* obj) const;

/**
* @js NA
* @lua NA
*/
friend class AutoreleasePool;

private:
// singleton类把构造函数和析构函数设为private，避免被调用
PoolManager();
~PoolManager();

void push(AutoreleasePool *pool);
void pop();

static PoolManager* s_singleInstance;

// 同样用vector来存放所管理AutoreleasePool对象指针的列表
std::vector<AutoreleasePool*> _releasePoolStack;
};

类实现

PoolManager* PoolManager::s_singleInstance = nullptr;

PoolManager* PoolManager::getInstance()
{
if (s_singleInstance == nullptr)
{
s_singleInstance = new PoolManager();
// Add the first auto release pool
new AutoreleasePool("cocos2d autorelease pool");
}
return s_singleInstance;
}

void PoolManager::destroyInstance()
{
delete s_singleInstance;
s_singleInstance = nullptr;
}

PoolManager::PoolManager()
{
_releasePoolStack.reserve(10);
}

PoolManager::~PoolManager()
{
CCLOGINFO("deallocing PoolManager: %p", this);
// 逐个析构所管理的AutoreleasePool对象
while (!_releasePoolStack.empty())
{
AutoreleasePool* pool = _releasePoolStack.back();
delete pool;
}
}

// 加入AutoreleasePool对象指针时用的是stl::vector的push_back函数，
// 于是调用back函数就可以得到最新被加入的AutoreleasePool对象指针
AutoreleasePool* PoolManager::getCurrentPool() const
{
return _releasePoolStack.back();
}

// 线性搜索每个被管理的AutoreleasePool，
// 每个AutoreleasePool对象再用contains函数线性搜索一遍
bool PoolManager::isObjectInPools(Ref* obj) const
{
for (const auto& pool : _releasePoolStack)
{
if (pool->contains(obj))
return true;
}
return false;
}

void PoolManager::push(AutoreleasePool *pool)
{
_releasePoolStack.push_back(pool);
}

void PoolManager::pop()
{
CC_ASSERT(!_releasePoolStack.empty());
_releasePoolStack.pop_back();
}

最后的疑问

使用C++的开发者看完上述代码后，可能对神秘的Ref::autorelease函数有疑问。从AutoreleasePool的源代码可知，被autorelease的对象最终还是通过release函数减少引用计数，只不过release函数由AutoreleasePool调用，调用位置在AutoreleasePool::clear()函数。那么AutoreleasePool如何自动管理内存？AutoreleasePool::clear()在哪里被调用？

谜底隐藏在cocos/base/CCDirector.cpp中：

void DisplayLinkDirector::mainLoop()
{
if (_purgeDirectorInNextLoop)
{
_purgeDirectorInNextLoop = false;
purgeDirector();
}
else if (! _invalid)
{
drawScene();
// release the objects
PoolManager::getInstance()->getCurrentPool()->clear();
}
}

这里不详细讨论Director类的实现细节，上述代码表明：在图像渲染的主循环中，如果当前图形对象在当前帧，则调用显示函数，并调用AutoreleasePool::clear()减少这些对象的引用计数。mainLoop每一帧都会自动调用，所以下一帧时这些对象都会被当前的AutoreleasePool对象release一次，这就是AutoreleasePool“自动”的由来。