性能优化之 — AS3.0对象池运用

以前做页面呈现，最近接触到动画较多，性能这块考虑需要非常慎重。

考虑运用对象池思想，保存可以重用的对象，控制内存消耗量。

从网上大师那里学来的技术，现在和大家分享一下。

1：Reusable类 (顾名思义:可重用的，可再利用的)

//Reusable类为对象池中的一个对象类
package ObjectPool
{
    /**
     * 池属性--池对象 
     * @author yao yf
     */
    public class Reusable {
        /**
         * DisplayObject 对象 子SWF
         */
        public var object:Object;
        /**
         * 对象池唯一给予对象的标识符
         */
        public var name:String;
        /**
         * 新建一个Reusable对象
         * @param   _obj 放入的对象 
         * @param   _name 对象的标识
         */
        public function Reusable(_obj:Object, _name:String):void {
            if (_name == "") {
                throw new Error("对象标识不能为空！");
                return;
            }
            object = _obj;
            name = _name;
        }
    }

2:ReusablePool单例类

//ReusablePool类为单例类 用来管理对象池中的增加与删除对象
package 
{
    import ObjectPool.Reusable;
    
    import mx.controls.Alert;

    /**
     * 对象池 用来存取加载的对象   防止内存泄漏
     * @example
     * 使用示例
     * <listing version='3'>
     * private var reusablepool:ReusablePool = ReusablePool.getInstance();
     * if (!reusablepool.hasReusable("swfUI")) {
     *    reusablepool.setReusable(new Reusable(loadmode.LoaderObj, "swfUI"));
     * }
     * var myReusable:Reusable = reusablepool.getReusable("swfUI");
     * var myLoader:Loader = myReusable.object as Loader;
     * addChild(myLoader);
     * </listing>
     * @author yao yf
     */
    public class ReusablePool {
        /**
         * 
         */
        private static var reusablePool : ReusablePool;
        /**
         * 池对象
         */
        private static var reusable:Reusable;
        /**
         * 用于存取对象
         */
        private static var reusableArr:Array = new Array();
        /**
         * 最大对象数量
         */
        private static var maxPoolSize:int = 1000;
        /**
         * @private
         * 此类为单例 不要实例化
         * @param   enforcer
         */
        public function ReusablePool(enforcer:AccessRestriction):void {
            if ( enforcer == null )
            {
                throw new Error("此类为单例 不要实例！" );
            }
        }
        /**
         * 单例此类
         * @return ReusablePool
         */
        public static function getInstance() : ReusablePool {
            if( reusablePool == null ) {
                reusablePool = new ReusablePool(new AccessRestriction());
            }
            return reusablePool;
        }
        /**
         * 设置最大对象数量
         * @param   value
         */
        public function setMaxPoolSize(value:Number):void {
            maxPoolSize = value;
        }
        /**
         * 获取池中对象
         * @param   name 获取对象的标识字符
         * @return Reusable对象
         */
        public function getReusable(name:String):Reusable {
            var index:int = -1;
            var len:int = reusableArr.length;
            for (var i:int = 0; i < len; i++)   {
                if (reusableArr[i].name == name) {
                    index = i;
                    break;
                }
            }
            if (index == -1) {
                throw new Error("查询不到此对象-> " + name);
            }
            reusable = new Reusable(reusableArr[index].object, reusableArr[index].name);
            return reusable;
        }
        /**
         * 存储对象到池中 
         * @param   reusable
         */
        public function setReusable(reusable:Reusable):void   {
            if (hasReusable(reusable.name)) {
                Alert.show("#重复存储相同对象或对象标识重复！");
                return;
            }
            if (reusableArr.length < maxPoolSize) {
                reusableArr.push({object: reusable.object, name: reusable.name});
            }else {
                throw new Error("对象池已满，请清除不需要的对象或设置对象池setMaxPoolSize");  
            }
        }
        /**
         * 删除池中指定标识的对象
         * @param name 要删除对象的标识符
         */
        public function removeReusable(name:String):void {
            var index:int = -1;
            var len:int = reusableArr.length;
            for (var i:int = 0; i < len; i++)   {
                if (reusableArr[i].name == name) {
                    index = i;
                    break;
                }
            }
            if (index == -1) {
                throw new Error("查询不到要删除的对象-> " + name);
                return;
            }
            reusableArr.splice(i, 1);
        }
        /**
         * 检查对象是否在池中
         * @param name 对象标识
         * @return Boolean
         */
        public function hasReusable(name:String):Boolean {
            var len:int = reusableArr.length;
            for (var i:int = 0; i < len; i++)   {
                if (reusableArr[i].name == name) {
                    return true;
                    break;
                }
            }
            return false;
        }
    }
}
class AccessRestriction {}

使用示例代码判断:

 　　　private var reusablepool:ReusablePool = ReusablePool.getInstance();
      if (!reusablepool.hasReusable("swfUI")) {
         reusablepool.setReusable(new Reusable(loadmode.LoaderObj, "swfUI"));
      }
      var myReusable:Reusable = reusablepool.getReusable("swfUI");
      var myLoader:Loader = myReusable.object as Loader;
      addChild(myLoader);