Cocos2dx的GC机制

垃圾回收（GC）

垃圾回收器将之前使用过的，但是现在不在使用（或者没有指针再指向）的内存空间称为“垃圾”，将这些“垃圾”收集起来以便再次利用的机制即称为“垃圾回收”。

Cocos2dx的GC机制

Cocos2dx使用基于引用计数的方式实现“垃圾回收”机制。简单理解为系统为每个对象记录了一个值，这个值用来表示对应的对象被引用的次数，当对象被引用的次数为0时，该对象被视为垃圾而被系统回收。

引用计数

Cocos2dx中的几乎所有对象都继承自Ref基类。Ref类的主要职责就是进行引用计数管理。下面是Ref类的头文件中的内容。

//CCRef.h
class CC_DLL Ref
{
public:
    void retain();//调用一次引用计数+1
    void release();//调用一次引用计数-1，在此方法中会判断引用计数值_referenceCount是否等于0，如果等于0，则将该对象delete
    Ref* autorelease();//加入自动释放池
    unsigned int getReferenceCount() const;//获取对象引用计数值
protected:
    Ref();//构造函数，在此处引用计数值_referenceCount被初始化为1
public:
    virtual ~Ref();
protected:
    unsigned int _referenceCount;//引用计数值
    friend class AutoreleasePool;

retain()和release()方法虽然能让我们手动的对引用计数进行管理，但也可能会产生意想不到的结果，比如说如果在需要调用release()方法的地方我们忘记调用，则会导致内存泄漏。AutoreleasePool（自动释放池）很好的解决了这个问题。Ref基类中的autorelease()方法就是用来将对象加入到一个AutoreleasePool中。

autorelease()

//CCRef.cpp
Ref* Ref::autorelease()
{
    PoolManager::getInstance()->getCurrentPool()->addObject(this);
    return this;
}

autorelease()方法将对象加入到一个AutoreleasePool中。在每一帧结束的时候，这个AutoreleasePool中的对象会被清理（在这个AutoreleasePool中的每个对象都会被调用一次release()方法，如果对象引用计数值为0，那么该对象被delete）。

//CCDirector.cpp
void Director::mainLoop()
{
    if (_purgeDirectorInNextLoop)
    {
        _purgeDirectorInNextLoop = false;
        purgeDirector();
    }
    else if (_restartDirectorInNextLoop)
    {
        _restartDirectorInNextLoop = false;
        restartDirector();
    }
    else if (! _invalid)
    {
        drawScene();
        PoolManager::getInstance()->getCurrentPool()->clear();//调用自动释放池对象的clear()方法
    }
}

//CCAutoreleasePool.cpp
void AutoreleasePool::clear()
{
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
    _isClearing = true;
#endif
    std::vector<Ref*> releasings;
    releasings.swap(_managedObjectArray);
    //swap交换技巧实现内存释放思想:
    //1.vector()使用vector的默认构造函数建立临时vector对象
    //2.在该临时对象上调用swap成员，swap调用之后对象_managedObjectArray占用的空间就等于一个默认构造的对象的大小，临时对象就具有原来对象_managedObjectArray的大小，而该临时对象随即就会被析构，从而其占用的空间也被释放。
    for (const auto &obj : releasings)
    {
        obj->release();//引用计数-1
    }
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
    _isClearing = false;
#endif
}

UI元素的自动释放

常用的Layer、Sprite等均继承自Node类。以Node类为例看一下Node对象nodeObj的引用计数值的变化过程。
首先，在nodeObj被create的时候，引用计数值被初始化为1，并加入到自动释放池。

//CCNode.cpp
Node * Node::create()
{
    Node * ret = new (std::nothrow) Node();//此时引用计数为1
    if (ret && ret->init())
    {
        ret->autorelease();//加入到自动释放池
    }
    else
    {
        CC_SAFE_DELETE(ret);
    }
    return ret;
}

通过addChild方法将nodeObj添加到父节点上（addChild最终都是调用addChildHelper方法），nodeObj对象被pushBack进一个vector中，pushBack方法中调用了ration()方法，nodeObj对象引用计数值为2。

//CCNode.cpp
void Node::addChildHelper(Node* child, int localZOrder, int tag, const std::string &name, bool setTag)
{
    auto assertNotSelfChild
        ( [ this, child ]() -> bool
          {
              for ( Node* parent( getParent() ); parent != nullptr;
                    parent = parent->getParent() )
                  if ( parent == child )
                      return false;
              
              return true;
          } );
    (void)assertNotSelfChild;
    
    CCASSERT( assertNotSelfChild(),
              "A node cannot be the child of his own children" );
    
    if (_children.empty())
    {
        this->childrenAlloc();
    }
    
    this->insertChild(child, localZOrder);
    
    if (setTag)
        child->setTag(tag);
    else
        child->setName(name);
        
    child->setParent(this);

    child->updateOrderOfArrival();

    if( _running )
    {
        child->onEnter();
        if (_isTransitionFinished)
        {
            child->onEnterTransitionDidFinish();
        }
    }

    if (_cascadeColorEnabled)
    {
        updateCascadeColor();
    }
    
    if (_cascadeOpacityEnabled)
    {
        updateCascadeOpacity();
    }
}

//CCNode.cpp
void Node::insertChild(Node* child, int z)
{
#if CC_ENABLE_GC_FOR_NATIVE_OBJECTS
    auto sEngine = ScriptEngineManager::getInstance()->getScriptEngine();
    if (sEngine)
    {
        sEngine->retainScriptObject(this, child);
    }
#endif
    _transformUpdated = true;
    _reorderChildDirty = true;
    _children.pushBack(child);//在此处child对象的引用计数被+1，此时child引用计数为2    
    child->_setLocalZOrder(z);
}

//CCVector.h
void pushBack(T object)
{
    CCASSERT(object != nullptr, "The object should not be nullptr");
    _data.push_back( object );
    object->retain();//引用计数+1
}

通过之前autorelease()的介绍可以知道，在当前帧结束的时候，自动释放池中的对象会调用一次release()，此时nodeObj的引用计数值为1。

最后，当nodeObj被remove的时候（最终调用detachChild方法），会再次调用nodeObj的release()方法，此时，引用计数值变为0，nodeObj被delete。

//CCNode.cpp
void Node::detachChild(Node *child, ssize_t childIndex, bool doCleanup)
{
    if (_running)
    {
        child->onExitTransitionDidStart();
        child->onExit();
    }
    if (doCleanup)
    {
        child->cleanup();
    }
    
#if CC_ENABLE_GC_FOR_NATIVE_OBJECTS
    auto sEngine = ScriptEngineManager::getInstance()->getScriptEngine();
    if (sEngine)
    {
        sEngine->releaseScriptObject(this, child);
    }
#endif 
    child->setParent(nullptr);
    _children.erase(childIndex);//此处会调用一次release()方法，引用计数值变为0
}

//CCVector.h
iterator erase(ssize_t index)
{
    CCASSERT(!_data.empty() && index >=0 && index < size(), "Invalid index!");
    auto it = std::next( begin(), index );
    (*it)->release();
    return _data.erase(it);
}