cocos2d-x V3.x内存管理分析

概述原文请猛戳： http://galoisplusplus.gitcafe.com/blog/2014/07/30/memory-management-in-cocos2d-x-v3/ cocos2d-x移植自Objective C的cocos2d，其内存管理其实也来自于OC。因而对于写过OC程序的朋友来讲，cocos2d-x的内存管理应该是一目了然的，但对于本渣这枚没接触过OC的C++码农来说，或

原文请猛戳：
http://galoisplusplus.gitcafe.com/blog/2014/07/30/memory-management-in-cocos2d-x-v3/

cocos2d-x移植自Objective C的cocos2d，其内存管理其实也来自于OC。因而对于写过OC程序的朋友来讲，cocos2d-x的内存管理应该是一目了然的，但对于本渣这枚没接触过OC的C++码农来说，或许直接看cocos2d-x源代码才是最直接快捷的方式。

Node类

我们首先来看Node类的代码，Node是cocos2d-x中极重要的基类，许多常用的Scene、Layer、MenuItem等都继承自Node。

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

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

下面让我们来看这个函数的实现。该函数采用二段式创建的方式——首先用new operator在heap中开辟空间并进行简单的初始化，假如new返回一个合法地址（cocos2d-x没有采用c++的异常处理机制），则接着init函数用于实际初始化Node的成员。只有在这二者都成功后，才把创建的指针设为`autorelease`（关于`autorelease`后面会继续解释）并返回。```c++Node * Node::create(){    Node * ret = new Node();    if (ret && ret->init())    {        ret->autorelease();    }    else    {        CC_SAFE_DELETE(ret);    }    return ret;}

对于创建失败的情况，cocos2d-x使用了下面的宏保证该指针被delete且被设为nullptr：

```c++

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

这个二段式的create函数在cocos2d-x中非常常用，因而cocos2d-x用了以下一个叫`CREATE_FUNC`来表示这个函数以便给继承Node的子类使用：```c++/** * 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）只需要在类声明(class declaration)中加入CREATE_FUNC(类名)（例如CREATE_FUNC(ExampleLayer)），再overrIDe下init函数即可。

Ref类

在cocos2d-x中，Node类的父类是Ref类，之前我们所看到的autorelease方法实际上就来自于这个父类。

下面我们先来看Ref类的声明，这里为了突出重点，我们忽略script binding的情况：

```c++
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采用引用计数（reference counting）的方法来管理某个指针所指向的某个对象，初始创建时计数是1，当计数变为0时该对象被析构；`retain`方法会增加计数并拿到所有权，而与之对应的，`release`方法会减少计数；`autorelease`是把所有权交给友类（frIEnd class）`autoreleasePool`，让它来决定何时减少计数，这个类我们后面会继续谈到。下面我们来看Ref类的实现（deFinition）：```c++#if CC_USE_MEM_LEAK_DETECTIONstatic voID trackRef(Ref* ref);static voID untrackRef(Ref* ref);#endif// 在初始化列表中将计数设为1Ref::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没有对应引起的（有木有想起C++中new和delete没对应所引起的内存泄露？）：

autorelease缺乏对应的retain。
例如：

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

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

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

```c++
// 前面我们分析过create函数，它会先用new operator得到对象，再调用autorelease方法
// 这里new和autorelease对应
auto obj = Node::create();
|- new Node();
|- autorelease();

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

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

autoreleasePool类

现在我们来看Ref类的友类autoreleasePool。
首先来看类声明：

```c++
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所指向的对象。要搞清楚原理还需要继续看它的实现：```c++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类

下面我们来看PoolManager类，在cocos2d-x中，这个类是典型的单例（singleton）工厂类——及有且只有一个PoolManager对象，该Poolmanger有一个存放autoreleasePool对象指针的stack，该stack是由STL::vector实现的。需要注意的是，cocos2d-x的单例类都不是线程安全的，跟内存管理紧密相关的PoolManager类也不例外，因此在多线程中使用cocos2d-x的接口需要特别注意内存管理的问题。

我们先来看类声明：

```c++
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;

};

再来看类实现：```c++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如何个「auto」自动管理内存法儿？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「自动」的来由。

总结

以上是内存溢出为你收集整理的cocos2d-x V3.x内存管理分析全部内容，希望文章能够帮你解决cocos2d-x V3.x内存管理分析所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。