程序博客网 > linux中uuid挂载分区

07 Cocos2d-x内存管理

来源：互联网 发布：linux中uuid挂载分区 编辑：程序博客网 时间：2024/06/16 08:50
引用计数的由来
cocos2d-x 的世界是基于 CCObject 类构建的，其中的每个元素：层、场景、精灵等都是一个个 CCObject 的对象。所以 内存管理的本质就是管理一个个 CCObject。作为一个 cocos2d 的 C++ 移植版本，在它之前有很多其它语言的 实现，从架构层次来说，这与语言的实现无关（比如 CCNode 的节点树形关系，其它语言也可以实现，如果是内存方便，C# 等更是无需考虑），但就从内存管理方面来说，参考了 OC （Objective-C） 的内存管理实现。
 
一个简单的自动管理原则：CCObject 内部维护着一个引用计数，引用计数为 0 就自动释放 ～（如果么有直接做如 delete 之类的操作）。那么此时可以预见，管理内存的实质就是管理这些 "引用计数" 了！使用 retain 和 release 方法对引用计数进行操作！
 
为什么要有自动释放池 及其作用
我们知道 cocos2d-x 使用了自动释放池，自动管理对象，知其然！其所以然呢？为什么需要自动释放池，它在整个框架之中又起着什么样的作用！在了解这一点之前，我们需要 知道 CCObject 从创建之初，到最终销毁，经历了哪些过程。在此，一叶总结以下几点：
 
1.刚创建的对象，而 为了保证在使用之前不会释放（至少让它存活一帧），所以自引用（也就是初始为1）
2.为了确定是否 实际使用，所以需要在一个合适的时机，解除自身引用。
3.而这个何时的时机正是在帧过度之时。
4.帧过度之后的对象，用则用矣，不用则弃！
5.由于已经解除了自身引用，所以它的引用被使用者管理（一般而言，内部组成树形结构的链式反应，如 CCNode）。
6.链式反应，也就是，如果释放一个对象，也会释放它所引用的对象。
 
上面是一个对象的大致流程，我们将对象分为两个时期，一个是刚创建时期，自引用为 1（如果为 0 就会释放对象，这是基本原则，所以要大于 0） 的时期，另一个是使用时期。上面说到，为了保证创
建时期的对象不被销毁，所以自引用(并没有实际的使用)初始化为 1，这就意味着我们需要一个合适的时机，来解除这样的自引用。
 
何时？在帧过度之时！(这样可保证当前帧能正确使用对象而没有被销毁。)怎么样释放？由于是自引用，我们并不能通过其它方式访问到它，所以就有了自动释放池，我们 变相的将“自引用”转化“自动释放池引用”，来标记一个 “创建时期的对象”。然后在帧过度之时，通过自动释放池管理，统一释放 “释放池引用”，也就意味着，去除了“自身引用”。帧过度之后的对象，才是真正的被使用者所管理。 下面我们用代码来解释上述过程。
 
通常我们使用 create(); 方法来创建一个自动管理的对象，而其内部实际操作如下：
  1. // 初始化一个对象 
  2. static CCObject* create()  
  3. { 
  4.     // new CCObject 对象 
  5.     CCObject *pRet = new CCObject();  
  6.     if (pRet && pRet->init())  
  7.     { 
  8.         // 添加到自动释放池 
  9.         pRet->autorelease();  
  10.         return pRet;  
  11.     }  
  12.     else  
  13.     {  
  14.         delete pRet;  
  15.         pRet = 0;  
  16.         return 0;  
  17.     }  
  18. } 
  19.  
  20. // 我们看到初始化的对象 自引用 m_uReference = 1 
  21. CCObject::CCObject(void) 
  22. :m_uAutoReleaseCount(0) 
  23. ,m_uReference(1) // when the object is created, the reference count of it is 1 
  24. ,m_nLuaID(0) 
  25. { 
  26.     static unsigned int uObjectCount = 0; 
  27.  
  28.     m_uID = ++uObjectCount; 
  29. } 
  30.  
  31. // 标记为自动释放对象 
  32. CCObject* CCObject::autorelease(void) 
  33. { 
  34.     // 添加到自动释放池 
  35.     CCPoolManager::sharedPoolManager()->addObject(this); 
  36.     return this; 
  37. } 
  38.  
  39. // 继续跟踪 
  40. void CCPoolManager::addObject(CCObject* pObject) 
  41. { 
  42.     getCurReleasePool()->addObject(pObject); 
  43. } 
  44.  
  45. // 添加到自动释放池的实际操作 
  46. void CCAutoreleasePool::addObject(CCObject* pObject) 
  47. { 
  48.     // 内部是由一个 CCArray 维护自动释放对象，并且此操作 会使引用 + 1 
  49.     m_pManagedObjectArray->addObject(pObject); 
  50.  
  51.     // 由于初始化 引用为 1，上面又有操作，所以引用至少为 2 （可能还被其它所引用） 
  52.     CCAssert(pObject->m_uReference > 1, "reference count should be greater than 1"); 
  53.     ++(pObject->m_uAutoReleaseCount); 
  54.     // 变相的将自身引用转化为释放池引用，所以减 1 
  55.     pObject->release(); // no ref count, in this case autorelease pool added. 
  56. } 
上面便是通过 create() 方法创建对象的过程。文中说到，一个合适的时机，解除自身引用（也就是释放池引用），那这又是在何时进行的呢？程序的运行有一个主循环，控制着每一帧的操作，在每一帧画面画完之时会自动调用 CCPoolManager::sharedPoolManager()->pop(); 方法 ( 具体可参见文章Cocos2d-x 程序是如何开始运行与结束的 ，这里我们只要知道每一帧结束都会调用 pop() 方法)，来自动清理 创建时期 的引用。现在我们就来看看 pop() 的方法实现：
  1. void CCPoolManager::pop() 
  2. { 
  3.     if (! m_pCurReleasePool) 
  4.     { 
  5.         return; 
  6.     } 
  7.  
  8.     // 当前释放池个数，pop 使用栈结构 
  9.      int nCount = m_pReleasePoolStack->count(); 
  10.     // 释放池当中存放的都是 创建时期 对象，此时解除释放池引用 
  11.     m_pCurReleasePool->clear(); 
  12.  
  13.     // 当前释放池，出栈，在这里可以看到判断 nCount 是否大于 1，文后将会对此做具体说明 
  14.       if(nCount > 1) 
  15.       { 
  16.         m_pReleasePoolStack->removeObjectAtIndex(nCount-1); 
  17.  
  18. //         if(nCount > 1) 
  19. //         { 
  20. //             m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2); 
  21. //             return; 
  22. //         } 
  23.         m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2); 
  24.     } 
  25.  
  26.     /*m_pCurReleasePool = NULL;*/ 
  27. } 
  28.  
  29. // 释放池引用清理工作 
  30. void CCAutoreleasePool::clear() 
  31. { 
  32.     // 如果释放池存在 创建时期 的对象 
  33.     if(m_pManagedObjectArray->count() > 0) 
  34.     { 
  35.         //CCAutoreleasePool* pReleasePool; 
  36. #ifdef _DEBUG 
  37.         int nIndex = m_pManagedObjectArray->count() - 1; 
  38. #endif 
  39.  
  40.         CCObject* pObj = NULL; 
  41.         CCARRAY_FOREACH_REVERSE(m_pManagedObjectArray, pObj) 
  42.         { 
  43.             if(!pObj) 
  44.                 break; 
  45.  
  46.             --(pObj->m_uAutoReleaseCount); 
  47.             //(*it)->release(); 
  48.             //delete (*it); 
  49. #ifdef _DEBUG 
  50.             nIndex--; 
  51. #endif 
  52.         } 
  53.         // 移除释放池对创建时期对象的引用，从而使对象交由使用者全权管理 
  54.         m_pManagedObjectArray->removeAllObjects(); 
  55.     } 
  56. } 
到这里，自动释放池的作用也就完成了！ 可以说创建的对象在一帧 (但有特殊情况，下一段说明) 之后就完全脱离了 自动释放池的控制，自动释放池，对对象的管理也就在 创建时期起着作用！之后便交由使用者管理，释放。
 
对"释放池"的管理说明
我们知道了释放池管理着 创建时期 的对象，那么对于释放池本身是如何管理的？我们知道对于释放池，只需要有一个就已经能够满足我们的需求了，而在 cocos2d-x 的设计中，使用了集合管理 一堆 释放池。而在实际，它们又发挥了多大的用处？
  1. // 释放池管理接口 
  2. class CC_DLL CCPoolManager 
  3. { 
  4.     // 释放池对象集合 
  5.     CCArray*    m_pReleasePoolStack; 
  6.     // 当前操作释放池 
  7.     CCAutoreleasePool*                    m_pCurReleasePool; 
  8.  
  9.     // 获取当前释放池 
  10.     CCAutoreleasePool* getCurReleasePool(); 
  11. public: 
  12.     CCPoolManager(); 
  13.     ~CCPoolManager(); 
  14.     void finalize(); 
  15.     void push(); 
  16.     void pop(); 
  17.  
  18.     void removeObject(CCObject* pObject); 
  19.     // 添加一个 创建时期 对象 
  20.     void addObject(CCObject* pObject); 
  21.  
  22.     static CCPoolManager* sharedPoolManager(); 
  23.     static void purgePoolManager(); 
  24.  
  25.     friend class CCAutoreleasePool; 
  26. }; 
  27.  
  28. // 我们从 addObject 开始看起，由上文可以 addObject 是由 CCObject 的 autorelease 自动调用的 
  29. void CCPoolManager::addObject(CCObject* pObject) 
  30. { 
  31.     getCurReleasePool()->addObject(pObject); 
  32. } 
  33.  
  34. CCAutoreleasePool* CCPoolManager::getCurReleasePool() 
  35. { 
  36.     // 如果当前释放池为空 
  37.     if(!m_pCurReleasePool) 
  38.     { 
  39.         // 添加一个 
  40.         push(); 
  41.     } 
  42.  
  43.     CCAssert(m_pCurReleasePool, "current auto release pool should not be null"); 
  44.  
  45.     return m_pCurReleasePool; 
  46. } 
  47.  
  48. void CCPoolManager::push() 
  49. { 
  50.     CCAutoreleasePool* pPool = new CCAutoreleasePool();       //ref = 1 
  51.     m_pCurReleasePool = pPool; 
  52.     // 像集合添加一个新的释放池 
  53.     m_pReleasePoolStack->addObject(pPool);                   //ref = 2 
  54.  
  55.     pPool->release();                                       //ref = 1 
  56. } 
从 addObject 开始分析，我们知道在 addObject 之前，会首先判断是否有当前的释放池，如果没有则创建，如果有，则直接使用，可想而知，在任何使用，任何情况，通过 addObject 只需要创建一个释放池便已经足够使用了。事实上也是如此。再来看 pop 方法。
  1. void CCPoolManager::pop() 
  2. { 
  3.     if (! m_pCurReleasePool) 
  4.     { 
  5.         return; 
  6.     } 
  7.  
  8.      int nCount = m_pReleasePoolStack->count(); 
  9.     // 清楚对 创建对象 的引用 
  10.     m_pCurReleasePool->clear(); 
  11.  
  12.     // 如果大于 1，这也保证着，在任何时候，总有一个释放池是可以使用的 
  13.       if(nCount > 1) 
  14.       { 
  15.           // 移除当前的释放池 
  16.         m_pReleasePoolStack->removeObjectAtIndex(nCount-1); 
  17.  
  18. //         if(nCount > 1) 
  19. //         { 
  20. //             m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2); 
  21. //             return; 
  22. //         } 
  23.         // 将当前释放池设定为前一个释放池，也就是 “出栈”的操作 
  24.         m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2); 
  25.     } 
  26.  
  27.     /*m_pCurReleasePool = NULL;*/ 
  28. } 
看到这里 我就不解了！什么情况下才能用到多个释放池？按照设计的逻辑根本用不到。带着这个疑问，我在 CCPoolManager::push() 方法之内添加了一句话打印（修改源代码） CCLog("这里要长长长的 **********"); ，然后重新编译源文件，运行程序，发现实际的使用中，push 只被调用了两次！我们知道，通过 addObject 可能会自动调用 push() 一次，但也仅有一次，所以一定是哪里手动调用了 push() 方法，才会出现这种情况，所以我继续翻看源代码，定位到了 bool CCDirector::init(void) 方法，在这里进行了游戏的全局初始化相关工作：
 
  1. bool CCDirector::init(void) 
  2. { 
  3.     CCLOG("cocos2d: %s", cocos2dVersion()); 
  4.  
  5.     ... 
  6.     ... 
  7.     m_dOldAnimationInterval = m_dAnimationInterval = 1.0 / kDefaultFPS;     
  8.     m_pobScenesStack = new CCArray(); 
  9.     m_pobScenesStack->init(); 
  10.  
  11.     ... 
  12.     ... 
  13.     m_fContentScaleFactor = 1.0f; 
  14.  
  15.     ... 
  16.     ... 
  17.     // touchDispatcher 
  18.     m_pTouchDispatcher = new CCTouchDispatcher(); 
  19.     m_pTouchDispatcher->init(); 
  20.  
  21.     // KeypadDispatcher 
  22.     m_pKeypadDispatcher = new CCKeypadDispatcher(); 
  23.  
  24.     // Accelerometer 
  25.     m_pAccelerometer = new CCAccelerometer(); 
  26.  
  27.  
  28.     // 这里手动调用了 push 方法，而在这之前的初始化过程中，间接的使用了 CCObject 的 autorelease，已经触发过一次 push 方法 
  29.     CCPoolManager::sharedPoolManager()->push(); 
  30.  
  31.     return true; 
  32. } 
 
所以我们便能够看到 push 方法被调用了两次，但其实如果我们把这里的手动调用放在方法的开始处，或者干脆就不使用 CCPoolManager::sharedPoolManager()->push(); ，对程序也没任何影响，这样从头到尾，只创建了一个自动释放池，而这里多创建的一个并没有多大的用处。 或者用处不甚明显，因为多创建一个释放池是有其效果的，效果具体体现在哪里，那就是 可以使调用 push() 方法之前的对象，多存活一帧。，因为 pop 方法只对当前释放池做了 clear 释放。为了方便起见，我们使用 Cocos2d-x 内存管理浅说 里面的方法观察每一帧的情况，看下面测试代码：
 
  1. // 关键代码如下 
  2. CCLog("update index: %d", updateCount); 
  3.  
  4. // 在不同的帧做相关操作，以便观察 
  5. if (updateCount == 1) { 
  6.     // 创建一个自动管理对象 
  7.     layer = LSLayer::create(); 
  8.     // 创建一个新的自动释放池 
  9.     CCPoolManager::sharedPoolManager()->push(); 
  10.     // 再创建一个自动管理对象 
  11.     sprite = LSSprite::create(); 
  12. } else if (updateCount == 2) { 
  13.  
  14. } else if (updateCount == 3) { 
  15.  
  16. } 
  17.  
  18. CCLog("update index: %d end", updateCount); 
  19.  
  20. /// 打印代码如下 
  21. cocos2d-x debug info [update index: 1] 
  22. // 第一帧创建了两个自动管理对象 
  23. cocos2d-x debug info [LSLayer().()] 
  24. cocos2d-x debug info [LSSprite().()] 
  25. cocos2d-x debug info [update index: 1 end] 
  26. // 第一个过度帧只释放了 sprite 对象 
  27. cocos2d-x debug info [LSSprite().~()] 
  28. cocos2d-x debug info [update index: 2] 
  29. cocos2d-x debug info [update index: 2 end] 
  30. // 第二个过度帧释放了 layer 对象 
  31. cocos2d-x debug info [LSLayer().~()] 
  32. cocos2d-x debug info [update index: 3] 
  33. cocos2d-x debug info [update index: 3 end] 
 可以对比 sprite 和 layer 对象，两个对象被放在了不同的自动释放池之中。这就是 手动调用 push() 方法所能达到的效果，至于怎么利用这个特性，帮助我们完成特殊的功能？我想还是不用了，这会增加我们程序设计的 复杂度，在我看来，甚至想把，cocos2d-x 2.0.4 中那唯一一次调用的 push() 给删了，以保持简单（程序的第一次初始化“可能”会用到这个特性，不过目测是没有多大关系的了 : P），在这里只系统通过这个例子理解 自动释放池是怎样被管理的即可！
 
从自动释放池管理 创建时期 对象，再到对释放池的管理，我们已经大概了解了一个对象的生命周期经历了哪些！ 下面简单说说 使用时期 的对象管理。
 
树形结构的链式反应
文中我们知道了，自动释放池的存在意义，在于对象 创建时期 的处理，而仅仅理解了自动释放池，对于我们使用 cocos2d-x 不够，远远不够！自动释放池只是解决对象初始化的问题，仅此而已，而要在整个使用过程中，相对的自动化管理，那么必须理解两个概念，树形结构 和 链式反应 （链式反应，不错的说法，就像原子弹爆炸一样，一传十，十传百 ：P）
 
我们当前运行这一个场景，场景初始化，添加了很多层，层里面有其它的层或者精灵，而这些都是 CCNode 节点，以场景为根，形成一个树形结构，场景初始化之后（一帧之后），这些节点将完全 依附 (内部通过 retain) 在这个树形结构之上，全权交由树来管理，当我们 砍去一个树枝，或者将树 连根拔起，那么在它之上的“子节点”也会跟着去除(内部通过 release)，这便是链式反应。
 
Cocos2d-x 内存管理的一种实现，此文这种实现的本质既是 强化这种 链式反应，也是解决内存可能出错的一个解决方案。如下（前文片段，具体详见前文）：
  1. // 方式一：那么我们的使用过程 
  2. LUser* lu = LUser::create(); 
  3. lu->m_sSprite = CCSprite::create("a.png"); 
  4. // 如果这里不 retain  则以后就用不到了 
  5. lu->m_sSprite->retain(); 
  6.  
  7. // 方式二：使用方法 
  8. LUser* lu = LUser::create(); 
  9. lu->m_sUserName = "一叶"; 
  10. // 这里的 sprite 会随着 lu 的消亡而消亡，不用管释放问题了 
  11. lu->setSprite(CCSprite::create("a.png")); 
 我们看到方式二相比方式一的设计，它通过 setSprite 内部对 sprite 本身 retain，从而实现链式反应，而不是直接使用 lu->m_sSprite->retain();，这样的好处是，我只要想着释放 LUser，而不用考虑LUser 内部 sprite 的引用情况就行了。如此才能把 cocos2d-x 内存的自动管理特性完全发挥 ~
 
而要实现这样管理的一个明显特征就是，隐藏 retain 和 release 操作 ~
 
稍作总结
关于 cocos2d-x 的内存管理从使用到原理，系列文章就到这里了！（三篇也算系列 = =!） 由表象到内部的思考探索过程，其实在 浅说 当中对 cocos2d-x 的使用，便已经能够知晓内部细节设计之一二，透过现象看本质！三篇文章包含了，使用浅说（简单的测试），一种防止内存泄漏的设计（加强链式反应），最后纵览 cocos2d-x 的内存管理框架，对 CCObject 的生命周期做了简单的说明，当然其中还是隐藏一些细节的，比如管理都是用 CCArray 来管理，但我们并没有对 CCArray 做介绍，它是如何添加元素，如何引用等。在任何时候我们只针对一个问题进行思考，那我们该把 CCArray 这样的辅助工具类放在何处，如果你了解当然最好，不过不了解，那便 存疑 ，然后对相应的问题，分而治之 ~
 
0 0
linux中uuid挂载分区 linux中uuid挂载分区
原创粉丝点击
热门IT博客
驱动精灵 linux版本驱动精灵 linux版本
呼吸阀计算软件呼吸阀计算软件
数据库子查询
知乎一个笑话笑一辈子
网络宣传公司
人工智能人才缺口
bosch博世淘宝上真的吗
沂蒙老兵淘宝
淘宝中小卖家是几心
九院13所知乎
js中的全局变量
知乎 小知识
阿里云邮箱登陆登录
无埋点数据采集
支撑点的算法
sql语句录入数据库
日服lol mac要加速器嘛
艾佛森体测数据
国产安全座椅品牌 知乎
影子网络真实事情
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 库乐队 乐队的夏天 黑豹乐队 痛仰乐队 新裤子乐队 皇后乐队 刺猬乐队 零点乐队 beyond乐队 花儿乐队 好妹妹乐队 裤子乐队 面孔乐队 梦龙乐队 乐队 库乐队下载 甲壳虫乐队 披头士乐队 随身乐队 杭盖乐队 九宝乐队 温拿乐队 摇滚乐队 反光镜乐队 草蜢乐队 旅行团乐队 酷玩乐队 酷乐队 老鹰乐队 夜愿乐队 gala乐队 涅槃乐队 深蓝乐队 中国乐队 康姆士乐队 旮旯乐队 灵感乐队 乐队歌曲 20088乐队 glay乐队 乐队来访

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里