Cocos2d-x 内存管理剖析（1）

下面这篇文章将深入cocos2dx引擎的源代码，剖析cocos2dx中内存的管理机制的实现。使用cocos2dx-2.1.5版本。

参考文章：点击打开链接 

一、前言：

我们都知道在c++中，创建实例化的对象都是使用new关键字，在不使用或者不需要的时候必须手动使用delete关键字去掉这个对象，否则new出来的对象就不能回收，造成内存泄露。

例如（我们创建了一个大小为10的数组）

int* p = new int[10];
    for (int i = 0; i<10; i++) {
        p[i] = i;
    }

如果使用结束后，不手动  delete [] p; 那么就会造成这个数组的内存泄露。

二、Cocos2d-x采用引用计数方式对对象进行内存管理

关于引用计数方式的内存管理，熟悉ios开发的人来说应该不陌生；其内存管理的过程大致是：为每一个对象保存一个引用计数，当引用计数大于0的时候，对象继续保存在内存中；但是当引用计数等于0的时候，自动释放这个对象，这个过程就是autorelease（自动管理）。

在Cocos2d-x中，CCObject是整个引擎的基础类，其他的类都是继承自这个类而来。

那么，首先从这个类开始进行内存管理的剖析：

在 libs/cocos2dx/cocoa/ 位置下找到这个类文件。

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) const;
    unsigned int retainCount(void) const;
    virtual bool isEqual(const CCObject* pObject);

    virtual void acceptVisitor(CCDataVisitor &visitor);

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

说明：

public 中的两个属性：对象的ID编号（其中第二个是用于Lua中的）；

protected 中的两个属性：

  m_uReference表示对象的引用计数；

  m_uAutoReleaseCount 则表示对象是否自动管理，也就是表示是否autorelease。注意到 m_uAutoReleaseCount 这个变量是unsigned int类型，在之前一些版本中，曾经是使用 bool m_bManaged 这个bool变量，其实本质是一样的，如果对象autorelease（自动管理），那么 ++m_uAutoReleaseCount，只要这个值非零，那么这个对象就是autorelease的。而假如是bool变量的话，那么就是让其变成true就是autorelease了。

前面说到，对对象的内存管理是使用到引用计数，那么我们就看看CCObject中，引用计数 m_uReference 是如何变化的吧！

首先我们进入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;
}

显然，创建一个CCObject对象之后，其引用计数 m_uReference 变为1，而 m_uAutoReleaseCount 为0，表示对象还没有autorelease。

接着就是retain和release方法了，前者对引用计数加1，后者引用计数减1。

void CCObject::release(void)
{
    CCAssert(m_uReference > 0, "reference count should greater than 0");
    --m_uReference;

    if (m_uReference == 0)
    {
        delete this;
    }
}

void CCObject::retain(void)
{
    CCAssert(m_uReference > 0, "reference count should greater than 0");

    ++m_uReference;
}

其中release方法中，如果引用计数 m_uReference 为0，那么就自动删除这个对象进行回收。

好了，通过上面的介绍我们就可以知道cocos2dx中的引用计数是怎么一回事了，接下来就是 ：引擎中是如何对实例对象进行自动管理。

三、实例对象自动管理autorelease

下面从一个CCNode创建的生命历程来讲一下这个自动管理的过程。

在 libs/cocos2dx/base_nodes 中找到CCNode的类文件。

进入其中的create方法。

CCNode * CCNode::create(void)
{
	CCNode * pRet = new CCNode();
    if (pRet && pRet->init())
    {
        pRet->autorelease();
    }
    else
    {
        CC_SAFE_DELETE(pRet);
    }
	return pRet;
}

其中 create 创建的过程是先用 new创建对象，然后将对象自动管理 autorelease。（所以我们就知道了，我们一般创建节点对象都使用create，其过程就是一个 new+autorelease = create）

进入其中的autorelease方法

CCObject* CCObject::autorelease(void)
{
    CCPoolManager::sharedPoolManager()->addObject(this);
    return this;
}

进入其中的addObject方法

void CCPoolManager::addObject(CCObject* pObject)
{
    getCurReleasePool()->addObject(pObject);
}

再进入其中的addObject方法

void CCAutoreleasePool::addObject(CCObject* pObject)
{
    m_pManagedObjectArray->addObject(pObject);

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

首先看一下在这个过程中我们遇到了这两个类：CCPoolManager 和 CCAutoreleasePool，前者是对象自动管理类，后者是对象自动管理（释放）池。后面再详细分析一下这个autorelease过程。

先看到CCAutoreleasePool这个类：

class CC_DLL CCAutoreleasePool : public CCObject
{
    CCArray*    m_pManagedObjectArray;    
public:
    CCAutoreleasePool(void);
    ~CCAutoreleasePool(void);

    void addObject(CCObject *pObject);
    void removeObject(CCObject *pObject);

    void clear();
};

类中有一个  m_pManagedObjectArray  数组，我们将对象自动管理后，都是将对象添加到这个数组中的，所以说是对象自动管理（释放）池。值得注意的是，这个类也是继承自CCObject，那么显然其内存管理形式也采用引用计数的。

其中的addObject方法就是将需要自动管理的对象添加到这个m_pManagedObjectArray数组中，那么就说将对象进行了自动管理autorelease。

下面进入这个方法看看：

void CCAutoreleasePool::addObject(CCObject* pObject)
{
    m_pManagedObjectArray->addObject(pObject);

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

首先是将对象添加到数组中，然后将对象自动管理变量++，那么对象的 m_uAutoReleaseCount =1，也就是表明其为自动管理对象。

然后对对象进行release，也即对对象的引用计数进行减1的操作，这个是为什么呢?

下面分析一个这个原因：

①首先一个CCNode对象被创建，使用的是new，也就是调用了构造方法，那么其引用计数 m_uReference=1。这个应该不难理解吧：CCNode是继承自CCObject，而在前面CCObject的构造方法中就知道，new创建一个实例对象后，其引用计数m_uReference=1，而是否自动管理变量 m_uAutoReleaseCount=0（表示对象未添加到自动管理（释放）池中自动管理）。

②接着对象autorelease，那么就是将对象添加到自动释放池中，而其中的：

m_pManagedObjectArray->addObject(pObject); 将被管理对象添加到自动管理池中的过程中（将对象添加到数组中），其会对对象进行retain的，所以 m_uReference 就变成了 m_uReference=2。

下面跟踪一下这个过程：

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();
	arr->arr[arr->num] = object;
	arr->num++;
}

看到最后方法中 object->retain(); 了吧！

③所以最后的release是为了将引用计数重新变成为1。这样的话，从对象创建，到被放到对象自动管理池，引用计数依然为1，被管理值也为1（表征对象是自动管理）。

下面看看 CCPoolManager 类，这个类顾名思义就知道是对对象自动释放池进行管理的类，它是一个单例类。

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;
};

这个类中的属性  m_pCurReleasePool 表示当前的自动释放池，可以使用  getCurReleasePool（）这个方法获取到当前的这个属性，进入这个方法：

CCAutoreleasePool* CCPoolManager::getCurReleasePool()
{
    if(!m_pCurReleasePool)
    {
        push();
    }

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

    return m_pCurReleasePool;
}

这个类中还有一个属性m_pReleasePoolStack 属于CCArray类型，表示对象自动释放池数组，其中可以有多个对象自动释放池。

比如说，在上面的 getCurReleasePool() 方法中，如果 m_pCurReleasePool 为空，那么就要进入push（）方法创建一个对象自动释放池，并且添加到m_pReleasePoolStack中。

void CCPoolManager::push()
{
    CCAutoreleasePool* pPool = new CCAutoreleasePool();       //ref = 1
    m_pCurReleasePool = pPool;

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

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

如代码所示，push（）操作 new 了一个自动释放池对象，并且将它赋值给 当前自动释放池（m_pCurReleasePool），然后将这个new的自动释放池对象放到CCPoolManager 里面的自动释放池数组中。

注意过程中对其引用计数的控制，自动释放池本身也是继承ccobject的，也有自己的引用计数，受相同的内存管理方式。其中的注释就表明了自动释放池对象的引用计数。

好，大致已经介绍了CCPoolManager 和 CCAutoreleasePool 这两个类，那么再来看将对象自动管理autorelease的过程就比较简单了。

首先调用构造方法，new一个对象（我们称之为object），然后这个对象调用autorelease方法，接着就是得到

CCPoolManager的单例变量，用getCurReleasePool() 方法获取到当前的对象自动释放池对象（如果没有的话，就新建一个对象自动释放池对象，并且添加到 对象自动释放池数组中），然后把这个object对象添加到自动释放池中的

m_pManagedObjectArray 数组中，执行完这个过程，这个新建的object对象的引用计数值为1，被管理状态值也为1（表征该对象是自动管理的）。

下面通过一个简单的例子来说明上面所讲述的内容：

1、new创建一个对象，还没有autorelease。

2、对对象进行autorelease操作

3、对对象进行retain操作：