原文请猛戳：
http://galoisplusplus.coding.me/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的静态对象指针：
/** * 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后面会继续解释）并返回。
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中非常常用，因而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）只需要在类声明(class declaration)中加入CREATE_FUNC(类名)（例如CREATE_FUNC(ExampleLayer)），再overrIDe下init函数即可。
在cocos2d-x中，_Node_类的父类是_Ref_类，之前我们所看到的autorelease方法实际上就来自于这个父类。
下面我们先来看Ref类的声明，这里为了突出重点，我们忽略script binding的情况：
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_DETECTIONpublic: static voID printLeaks();#endif}; 从上面的代码，我们可以初步了解到：Ref采用引用计数（reference counting）的方法来管理某个指针所指向的某个对象，初始创建时计数是1，当计数变为0时该对象被析构；retain方法会增加计数并拿到所有权，而与之对应的，release方法会减少计数；autorelease是把所有权交给友类（frIEnd class）autoreleasePool，让它来决定何时减少计数，这个类我们后面会继续谈到。
下面我们来看Ref类的实现（deFinition）：
#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。
例如：
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函数构造的对象）必须先retainobj->retain();obj->autorelease();
又如：
auto obj = Node::create();// 这里retain和release对应，release一个已经被autorelease过的对象（例如通过create函数构造的对象）必须先retainobj->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类 下面我们来看PoolManager类，在cocos2d-x中，这个类是典型的单例（singleton）工厂类——及有且只有一个PoolManager对象，该Poolmanger有一个存放autoreleasePool对象指针的stack，该stack是由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如何个「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内存管理分析所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）