内存优化——对象池

1：不用的事件及时remove，或者用弱引用

2：减少显示对象的使用

3：如果对一个对象要频繁使用时，用对象池

 

关于对象池

对象池的工作原理：   对象池的工作原理的核心有两点：使用和缓存，即对于那些被频繁使用的对象，在使用完后，不立即将它们释放，而是将它们缓存起来，以供后续的应用程序重复使用，从而减少创建对象和释放对象的次数，进而改善应用程序的性能。

优点：能快速取出对象节省了 NEW 对象所产生的 cpu ，时间的消耗。能很好的控制内存的占用，使用时从对象池取出，使用完毕放回。中间不涉及到对象销毁创建，所以内存占用是定量的。同时如果对象池提前

缺点：对象池同样消耗 new 同样对象所消耗的时间，对象池从创建到结束消耗定量的内存。对象池只适合大量的对象需要被重复创建使用销毁创建使用销毁的情况。非提前初始化式内存池，缓存 as 值类型的对象如： Point 反而产生更大的消耗。

例子：

--------------------------------array-------------------------------------------

1.  package wingox.pool {  

2.      import flash.utils.Dictionary;  

3.   

4.      /**  

5.       * @version 20100315  

6.       * @author BrightLi  

7.       */  

8.       public  class ObjectPool {  

9.   

10.         private  static  var _pool : Dictionary = new Dictionary( true );  

11.  

12.         private var _template : Class;  

13.  

14.         private var _list : Array;  

15.  

16.          public   function  ObjectPool(value : Class) {  

17.             _template = value;  

18.             _list = new Array();  

19.         }  

20.  

21.          public   function  borrowObject() : Object {  

22.             if(_list.length > 0) {  

23.                  return  _list.shift();  

24.             }  

25.              return  new _template();  

26.         }  

27.  

28.          public   function  returnObject(value : Object) : void {  

29.             _list.push(value);  

30.         }  

31.  

32.          public   static   function  getPool(value : Class) : ObjectPool {  

33.             if(!_pool[value]) {  

34.                 _pool[value] = new ObjectPool(value);  

35.             }  

36.              return  _pool[value];  

37.         }  

38.     }  

39. }

----------------------------------------------- Dictionary ----------------------------------------------------

package  {

import flash.utils.Dictionary;

import flash.utils.getDefinitionByName;

import flash.utils.getQualifiedClassName;

/**

* 用于显示对象的对象池类

* @author yanghongbin

*/

public class DisplayObjectPool {

private static var instance:DisplayObjectPool;

/**

*   作为对象池的词典 dict

*/

private var objPoolDict:Dictionary = new Dictionary();

public function DisplayObjectPool() {

}

public static function getInstance():DisplayObjectPool {

if (instance == null) {

instance = new DisplayObjectPool();

}

return instance;

}

/**

* 向对象池中放入对象，以便重复利用

* @param disObj 要的放入对象

*

*/

public function push(oldObj:Object):void {

var objName:String = getQualifiedClassName(oldObj);

if (oldObj == null) {

return ;

}

if (this.objPoolDict[objName] == null) {

this.objPoolDict[objName] = [];

}

this.objPoolDict[objName].push(oldObj);

}

/**

* 从对象池中取出需要的对象

* @param targetObj 需要的对象类类名，没必要必须是类实例名 类名就可以

* @return 取出的相应对象

*

*/

public function pop(targetObj:Object):Object {

var objName:String = getQualifiedClassName(targetObj);

trace(objName);

if (this.objPoolDict[objName] != null && this.objPoolDict[objName].length > 0) {

return this.objPoolDict[objName].pop()as Object;

}

var objClass:Class = getDefinitionByName(objName)as Class;

var obj:Object = new objClass as Object;

return obj;

}

}

}