[转] gc tips(2)

时间:2023-03-09 09:18:47
[转] gc tips(2)

原文地址:http://kevincao.com/2011/08/actionscript-garbage-collection-1/

谈谈ActionScript垃圾回收(上)

在《给AS程序员的一点建议一文》中我提到了释放资源的重要性。最近在一些项目过程中我又对这方面有了更多的理解,在此希望能够分享给大家。首先让我们来回顾一下关于垃圾回收(Garbage Collection,下文简称GC)的一些知识。要阅读本文,你需要对GC机制有些基本认识。

在ActionScript中,我们没有API可以直接删除一个对象,也不能控制Player进行GC。但是GC的行为是可以预估的,作为开发者,我们需要了解的是GC执行的时机是发生在需要向操作系统请求分配内存的时候。

[转] gc tips(2)

从上面的模拟图我们可以看到:

  • Player以块的方式请求和释放内存。GC的结果不一定就是更少的内存占用,也有可能是从操作系统获得更多的可用内存。
  • Player会在某些GC过程中把内存中未使用部分组合成可以释放的块还给操作系统。
  • 此外还要注意的是Player为了避免占用太多的CPU资源,会将一些GC操作分到不同的时间片中运行,所以一次GC过程并不一定清理完所有可回收资源。

一次GC过程(GC Pass)分为以下两个步骤:

Reference Counting

统计所有对象的引用计数,如果某个对象没有任何引用,就标记为可回收。

[转] gc tips(2)

这个操作很好理解,需要强调的是weak reference(弱引用)是不参与计算的。引用计数是一个相对省CPU的操作,能够筛选出大部分可回收资源,但是对一些循环引用的情况就无能为力了。在下图中,标记为绿色的对象每个的引用数都为1,但它们明显是应该被回收的。

[转] gc tips(2)

所以GC需要进行第二个步骤:

Mark Sweeping

这个步骤是从根对象(Root)开始轮询对象的引用。所谓的根对象包括:

  • Stage对象
  • 静态变量
  • 局部变量

这种方式足够精确,能够成功筛选出上图中绿色标记的对象,而它的代价就是较大的计算开销。

为了帮助GC过程更高效的执行,最好是能在第一步引用计数中就把需要回收的对象都标记出来。具体的做法就是把所有不需要的对象引用全部清空,包括:

  • 删除成员变量的引用
  • 从可视对象列表上移除对象
  • 移除事件监听

难点:事件监听是否会造成对象不能回收?这个问题要具体分析,有些情况可以,有些情况却不可以。归根结底还是引用关系的问题。来看下面这个例子:

  1. Foo.as:
  2. public class Foo extends Sprite
  3. {
  4. private var bar:Sprite;
  5. public function Foo()
  6. {
  7. bar = new Sprite();
  8. //...
  9. //监听bar发出的事件。可以看作是bar引用了foo,因为foo的引用被保存在bar的监听者数组里。
  10. bar.addEventListener(MouseEvent.CLICK, clickHandler);
  11. addChild(bar);
  12. }
  13. private function clickHandler(event:MouseEvent):void
  14. {
  15. ...
  16. }
  17. }
  1. Main.as:
  2. // 创建foo实例
  3. var foo:Foo = new Foo();
  4. addChild(foo);
  5. // do something with foo...
  6. // 清除foo的引用
  7. removeChild(foo);
  8. foo = null;

我们看到foo引用了bar,而bar又通过事件监听的联系引用了foo,这就构成了一个循环引用。根据前文对GC步骤的分析,这两个对象都必须到第二步mark and sweep才能被标记出来。

如果我们对事件监听用弱引用的方式:

  1. bar.addEventListener(MouseEvent.CLICK, clickHandler, false, 0, true);

由于弱引用不计入引用计数,所以现在foo的引用数为0。GC在第一步操作中就能把foo标记出来,从而减少了一些运算开销。这也是为什么Grant Skinner呼吁把弱引用作为事件监听的默认方式的原因。

但是作为最佳实践,我们还是提倡要手动移除事件监听。以下代码添加一个destroy()方法(也有习惯命名为dispose()或kill()等)到Foo对象中:

  1. public function destroy():void
  2. {
  3. bar.removeEventListener(MouseEvent.CLICK, clickHandler);
  4. removeChild(bar);
  5. bar = null;
  6. }

在清除foo的引用之前执行destroy()方法:

  1. foo.destroy();
  2. removeChild(foo);
  3. foo = null;

经过我们如此处理,两个对象的引用数全都为0。GC只需第一步处理就完成任务,我们节约了更多的运算开销!

从上例可以看出在一般情况下,监听子对象的事件不会影响GC。不管是弱引用方式的监听,还是显式移除监听,都只是帮助GC更高效运行的手段,而不会影响GC的结果。但是如果事件监听造成的是对象以外的引用关系,情况就不同了,并且很有可能造成回收失败。一个常见的错误例子是监听Stage对象的RESIZE事件,如果没有显式移除这个监听或者是没有采用弱引用方式,那么这个对象就不会被GC回收的。所以我建议大家还是要尽可能的显式移除监听,切断引用关系。

我们现在已经用对GC最友好的方式做好了清理准备,但是对象还没有从内存中删除。在等待GC执行的这段时间,对象内的代码还在继续执行。比如加在对象上的ENTER_FRAME事件监听处理还在继续执行,对象内的MovieClip或Sound都还在继续播放。我们一定要避免这种情况的发生,所以在切断引用之前,我们还要在destroy()方法中做些清理工作。我们要做的工作包括:

  • clearInterval(),clearTimeout()
  • timer.stop()
  • loader.unload()/loader.unloadAndStop()
  • movieclip.stop() 如果有子MC的,也要停止播放
  • bitmapData.dispose()
  • 关闭LocalConnection,NetConnection,NetStream
  • 停止音频和视频的播放
  • 删除Camera和Microphone对象的引用
  • 调用子对象的destroy()方法,如果有的话

其实这些都是在开发中管理资源的基本常识,归结为一句话就是:谁创建了对象,谁就要负责清理该对象。

下面就以一些我在实际项目中开发的destroy()方法为例,看代码说话:

  1. public function destroy():void
  2. {
  3. // List是一个继承自Sprite的自定义子类
  4. // 移除list的事件监听
  5. list.removeEventListener.remove(MouseEvent.CLICK, clickHandler);
  6. // 我们创建了list实例,也要负责清理
  7. // 调用list对象自己的destroy()方法
  8. list.destroy();
  9. // 将list从显示列表移除
  10. // 这一步并非必须的步骤,原因是list的父对象会被移除,这样list和stage就没有联系了。
  11. // 但是在我的代码中,list还有可能会被添加到外部的容器中(比如stage),那么这一步就是必须的了。
  12. list.parent.removeChild(list);
  13. list = null;
  14. // --------------------
  15. // loader是一个来自tweenmax类库中的ImageLoader实例
  16. // 如果loader已经创建
  17. if(loader)
  18. {
  19. // 调用loader的dispose()方法,优秀的第三方类库都应该有良好的资源管理机制。
  20. // 参数true表示把加载的内容从显示列表上移除,帮我们节约了代码。
  21. loader.dispose(true);
  22. loader = null;
  23. }
  24. // --------------------
  25. // lightbox实例变量保存了一个外部引用
  26. // 根据谁创建谁清理的原则,我们在这里不需要负责该对象的清理,只要删除引用就可以了。
  27. lightbox = null;
  28. }

另一个示例的destroy()方法演示了对数组中对象的处理方法:

  1. public function destroy():void
  2. {
  3. // cells是一个数组,包含了一组子对象
  4. var i : int, n : int;
  5. n = cells.length;
  6. for(i = 0; i < n; i++)
  7. {
  8. // 执行每一个子对象的destroy()方法
  9. cells[i].destroy();
  10. // 删除子对象的引用
  11. cells[i] = null;
  12. }
  13. // 删除数组自身的引用
  14. cells = null;
  15. // 如果不需要得到每一个子对象的引用,我们也可以简单的用以下代码来清理数组:
  16. //cells.length = 0;
  17. //cells = null;
  18. }

在结构更复杂的项目里,我们还可以抽象出一个IDestroyable接口,让需要执行清理的自定义对象实现这个接口。这样我们的清理代码可以写为:

  1. var n:int = this.numChildren;
  2. for(var i:int = n-1; i >= 0; i--)
  3. {
  4. if(this.getChildAt(i) is IDestroyable)
  5. {
  6. IDestroyable(this.getChildAt(i)).destroy();
  7. this.removeChildAt(i);
  8. }
  9. }

总结:GC好比是ActionScript城市的环卫工人,我们的每个类都是从事劳动生产的市民。优秀的市民会把生产垃圾分类安放到回收点,而不文明的市民则把垃圾丢得到处都是。你说那种做法让城市的清扫工作变得更加高效?所以请大家谨记“谁创建谁清理”的原则,做一位ActionScript好市民。

本文回顾了GC的一些基本知识和最佳实践。在下一篇中我将结合一些具体问题,为大家把脉GC的疑难杂症。敬请期待。

继续阅读:

谈谈ActionScript垃圾回收(下)

参考资料: