AS3 内存回收机制

AS3 内存回收机制
AS3 内存回收机制

AS3 内存回收机制

一、AS3 内存回收机制 (1)

二、AS3 内存回收机制 (2)

三、AS3强制内存回收方法之二 (4)

四、AS3 释放内存 (6)

五、AS3中的内存泄露与垃圾回收 (8)

六、AS3 内存释放优化原则 (9)

七、as3 内存回收机制测试 (10)

八、AS3内存优化13条 (12)

九、AS3的垃圾回收机制详解 (14)

十、flash as3 内存管理和资源管理 (18)

十一、轻松几行让你AS3程序不再“内存泄露 (18)

注意:本资源多半来源于互联网sword收集

一、AS3 内存回收机制

1.什么是垃圾回收器

垃圾收集器是一个后台进程它负责回收程序中不再使用的对象占用的内存。非活动对象就是不再有任何其他活动对象引用它。为便于理解这个概念,有一点非常重要,就是要意识到除了非原生类型(Boolean, String, Number, uint, int 除外),你总是通过一个句柄访问对象,而非对象本身。当你删除一个变量其实就是删除一个引用,而非对象本身。

2.as中内存机制的方法

首先是引用计数法:

引用计数法是一种用于跟踪活动对象的较为简单的方法,当你创建一个指向某个对象的引用,该对象的引用计数器加1;当你删除该对象的一个引用,该计数器减1.当某对象的计数器变成0,该对象将被标记以便垃圾回收器回收。

var a:MovlieClip = new MovieClip();

addChild(a); // a的引用计数器为1

var b:MovieClip = a;//a的引用计数器为2

addChild(b);

removeChild(a);

a = null;//a的引用计数器为1

removeChild(b);

b = null; //a的引用计数器为0

其次是标志清除法:

清除法查找非活动对象。FlashPlayer从你的应用程序根对象开始(ActionScript3.0中简称为root)直到程序中的每一个引用,都为引用的对象做标记。接下来,FlashPlayer遍历所有标记过的对象。它将按照该特性递归整个对象树。并将从一个活动对象开始能到达的一切都标记。该过程结束后,FlashPlayer可以安全的假设:所有内存中没有被标记的对象不再有任何活动引用,因此可以被安全的删除。下图就是那张十分有名的图了:

绿色引用(箭头)曾被FlashPlayer 标记过程中经过,绿色对象被标记过,白色对象将被回收。

最后就是几种比较常见的内存泄露情况:

1. 引用泄露:对子对象的引用,外部对本对象或子对象的引用都需要置null;

2. 系统类泄露:使用了系统类而忘记做删除操作了,如BindingUtils.bindSetter(),ChangeWatcher.watch()函数时候完毕后需要调用ChangeWatcher.unwatch()函数来清除引用,否则使用此函数的对象将不会被删除;类似的还有MUSIC,VIDEO,IMAGE,TIMER,EVENT,BINDING等。

3. 效果泄露:当对组件应用效果Effect的时候,当本对象本删除时需要把本对象和子对象上的Effect动画停止掉,然后把Effect的target对象置null; 如果不停止掉动画直接把Effect置null将不能正常移除对象。

4. SWF泄露:要完全删除一个SWF要调用它的unload()/unloadAndStop()方法并且把对象置null;

5. 图片泄露:当Image对象使用完毕后要把source置null,加载图片的时候最好draw 一个出来,然后将loader处理掉。

6. 声音、视频泄露: 当不需要一个音乐或视频是需要停止音乐,删除对象,引用置null;

二、AS3 内存回收机制

AS3通过垃圾回收(Garbage Collection)移除不需要的对象,它需要一定条件。AS3中的对象被回收需要达到一定条件:

1、该对象无法通过任何变量访问。也就是没有变量指向该对象,或者指向该对象的变量生命周期结束。

2、程序中所有对象所占的内存接近当前系统分配给Flash运行的内存容量时,触发回收机制,移除符合条件1的对象。

这里的第二个条件我们无法控制,没有办法手工强制执行垃圾回收,所有不用的对象都是间接移除,也就是不可能即刻移除。这和ActionScript的Increment Mark And Sweep移除策略有关。不再详细讨论。

那么我们要做的工作就是满足第一个条件,让对象符合被回收的条件。

总结一下如何来满足条件:

1、移除该对象的所有引用,也就是所有引用该对象的变量赋值为null,或刻意的限制该变量的生命周期。

2、对于显示对象或某个数组中的元素,应该在显示列表或该数组中将其移除,再赋值null。

3、该对象注册的所有事件侦听应该被移除,否则该事件依然运行(内存中还在)。如果无法直接删除事件,那么注册侦听的时候应设置为弱引用。

4、暂停该对象的时间线(MC)动画。

5、停止该对象内创建的定时器和移除相关的时间间隔事件。

6、停止该对象中的任何流操作,比如声音流等。

最简单的比如加载图片的Loader的对象,加载完成一定要remove掉侦听,释放时清除对加载内容的引用,调用unload函数清空LoadInfo,再把loader清除出显示列表,赋值为null。

还有当我们在加载另一个swf时,移除loader的同时,不要忘记暂停时间动画,关闭该swf中的流,否则内存中依然存在的的该对象

尽最大可能的重用对象,这样效率要高,而不是让对象老是生存和死亡

三、AS3强制内存回收方法之二

以前我们最熟悉的强制内存回收的方法是:

1.function GC():void{

2. try{

3. (new LocalConnection).connect("foo");

4. (new LocalConnection).connect("foo");}catch(e){

5. trace(System.totalMemory);

6. }

7. }

复制代码

//由于上次试验弱引用的时候,发现当轮询本地sharedobject对象的时候,导致弱引用的内容进行了回收,于是联想用来进行强制内存回收..代码如下:

1.package {

2. /**

3. * @author CYPL

4. * @date 2009-04-01

5. */

6. import https://www.360docs.net/doc/f610882542.html,.SharedObject;

7. import flash.system.System;

8. import flash.utils.clearInterval;

9. import flash.utils.setInterval;

10.

11. public class GCPlus {

12. public static function clear(isTraceTM : Boolean = false) : void {

13. var time : int = 2;

14. var interval : int = setInterval(loop, 50);

15. function loop() : void {

16. if(!(time--)) {

17. isTraceTM &&

trace(System.totalMemory);

18. clearInterval(interval);

19. return;

20. }

21. SharedObject.getLocal("cypl", "/");

22. }

23. }

24. }

25.}

复制代码

//测试文档类:

1.package {

2. import flash.display.MovieClip;

3. import flash.display.Sprite;

4. import flash.events.MouseEvent;

5. import flash.system.System;

6.

7. /**

8. * @author CYPL

9. */

10. public class GC_Test extends Sprite {

11. private static const NUM : int = 1000;

12. private var num : int;

13.

14. public function GC_Test() {

15. init();

16. }

17.

18. private function init() : void {

19. num = NUM;

20. stage.addEventListener(MouseEvent.CLICK, clickHandler);

21. while (num--) {

22. var mc : MovieClip = new MovieClip;

23. mc.graphics.beginFill(0);

24. mc.graphics.drawRect(0, 0, 100, 100);

25. mc.x = Math.random() * 500;

26. mc.y = Math.random() * 400;

27. addChild(mc);

28. }

29.

30. trace(System.totalMemory);

31. }

32.

33. private function clickHandler(e : MouseEvent) : void {

34. clear();

35. }

36.

37. private function clear() : void {

38. while (numChildren) {

39. removeChildAt(0);

40. }

41. GCPlus.clear(true);

42. }

43. /*function GC():void{//这是我们熟悉的方法

44. try{

45. (new LocalConnection).connect("foo");

46. (new LocalConnection).connect("foo");}catch(e){

47. trace(System.totalMemory);

48. }

49. }*/

50. }

51.}

复制代码

通过System.totalMemory的结果可以清楚的看到内存得以释放,window任务管理器也能够看到有变化哦,原理也可能和异常有点关系.

补充下:也许大家试验其他的异常方法,在IDE调试下也能看到内存释放,但是独立的swf测试的时候,会看到任务管理器中内存并没有得到释放. 目前也只发现传统的LC方法和我上面提到的SO的方法能独立测试也能够达到释放的效果,假如还有新的可能,大伙都来补充下咯

四、AS3 释放内存

在Flash Player 的发行版中无法直接启动垃圾回收器。要确保将一个对象作为垃圾回收,请删除对该对象的所有引用。请记住,在ActionScript 1.0 和 2.0 中使用的旧delete 运算符在Act ionScript 3.0 中有不同的行为。它只能用于删除动态对象的动态属性。

注:在Adobe? AIR? 和Flash Player 的调试版中可以直接调用垃圾回收器。

例如,以下代码将Sprite 引用设置为null:

var mySprite:Sprite = new Sprite();

// Set the reference to null, so that the garbage collector removes

// it from memory

mySprite = null;

请记住,当对象设置为null 时,不必将其从内存中删除。如果系统认为可用内存不是足够低,垃圾回收器可能不会运行。垃圾回收的执行时间不可预知。内存分配(而不是对象删除)会触发垃圾回收。当垃圾回收器运行时,它将查找尚未收集的对象的图形。垃圾回收器通过在这些图形中查找相互引用但应用程序不再使用的对象,从而检测出处于非活动状态的对象。将删除通过这种方式检测到的处于非活动状态的对象。

在大型应用程序中,此进程会占用大量CPU 并影响性能,还可导致应用程序运行速度显著降低。通过尽量重复使用对象,尝试限制使用垃圾回收。此外,尽可能地将引用设置为null,以便垃圾回收器用较少处理时间来查找对象。将垃圾回收看作一项保护措施,并始终尽可能明确地管理对象生存期。

注:将对显示对象的引用设置为null 不能确保冻结该对象。该对象在作为垃圾回收之前,仍将占用CPU 周期。在将对对象的引用设置为null 之前,先确保正确地停用对象。

可使用Adobe AIR 和Flash Player 的调试版中提供的System.gc() 方法启动垃圾回收器。将此设置与Adobe? Flash? Builder? 捆绑还可以手动启动垃圾回收器。通过运行垃圾回收器,可以了解应用程序的响应方式以及是否已将对象从内存中正确删除。

注:如果将某个对象用作事件侦听器,则其他对象可以引用它。如果是这样,先使用removeE ventListener() 方法删除事件侦听器,然后再将引用设置为null。

幸运的是,这样可以立即减少位图使用的内存量。例如,BitmapData 类包括一个dispose() 方法。下面的示例将创建一个 1.8 MB 的BitmapData 实例。当前使用的内存增大到 1.8 MB,Syste m.totalMemory 属性返回一个更小的值:

trace(System.totalMemory / 1024);

// output: 43100

// Create a BitmapData instance

var image:BitmapData = new BitmapData(800, 600);

trace(System.totalMemory / 1024);

// output: 44964

然后,手动将BitmapData 从内存中删除并再次检查内存使用情况:

trace(System.totalMemory / 1024);

// output: 43100

// Create a BitmapData instance

var image:BitmapData = new BitmapData(800, 600);

trace(System.totalMemory / 1024);

// output: 44964 image.dispose();

image = null;

trace(System.totalMemory / 1024);

// output: 43084

尽管dispose() 方法可删除内存中的像素,但仍必须将引用设置为null 才可完全释放内存。当不再需要BitmapData 对象时,要始终调用dispose()方法并将引用设置为null,以便立即释放内存。

注:Flash Player 10.1 和AIR 1.5.2 在System 类中引入了一个名为disposeXML() 的新方法。借助此方法,通过将XML 树作为参数传递,可立即使XML 对象可用于垃圾回收。

五、AS3中的内存泄露与垃圾回收

内存泄露与垃圾回收可以说是程序在运行的时候遇到的两个比较重要的问题,这关系到我们程序是否能在机器中正确而有效的运行,你总不希望当你的程序运行一段时间后就弹出“内存******不能为re ad”的问题吧!很多计算机用户都特别讨厌这个提示。因为只要出现这个错误,程序就会立即关闭(大多数情况下是这样的!)令人烦恼的是,这种错误不可避免。因为一个应用程序少则几千行代码,多则几十万行,甚至上百万行。虽然内存泄露可以通过一定的技术手段排查出来,但是面对这么多的代码,相信再有经验的程序员都会望而却步。所以,我们在编写我们的程序时,尽量避开这些问题。像AS3这样的语言处理内存是贵垃圾回收机管的,我们不能自己去执行清楚内存操作,除非你用的是C或C++。其实现在大部分编程语言都用的是垃圾回收机,在一定程度上给我们的程序编写带来了便利,但同时也会产生问题,比如java,c#,vb等等,这些语言都是使用的垃圾回收机。AS3也是,那么垃圾回收机在什么情况下会产生内存泄露呢?

首先,你要明白什么是内存泄露。在计算机科学中,内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失,而是应用程序分配某段内存后,由于设计错误,失去了对该段内存的控制,因而造成了内存的浪费。(摘自百度百科)其实,内存泄露很简单,就是我们的程序创建了一个内存快,然后程序继续执行,最后,程序无法在控制这个内存块了。这就好比放羊,我们应该控制我们的羊群去吃草,而不是羊吃完草后,羊就丢了!看似是一个笑话,可这种情况在我们的程序中常常能够见到。知道了内存泄露,你也应该明白我们的程序有效的控制内存是多么的重要了吧!下面我们说说FLASH是如何控制内存的,以及什么时候FLASH对内存失去控制。

垃圾回收机!什么是垃圾?不用的内存不就是垃圾吗?正确!我认为没用的内存都是垃圾!(因为我的机器只有512M内存,内存对我来说太重要了!)清除内存迫在眉睫!但是FLASH不会像你想象的那样勤快的工作。假设我们创建了一个对象。

var a:Object = {name:mebiusshan};

好了!你能从中看到什么呢?难道你只看到了一个object对象吗?那你的目光就有些短浅了!最少你应该知道,在这个语句中我们创建了一个引用和一个

内存块(我不知道内存块用来这里是否合适,暂且这么说吧)引用即a,这是对内存的引用,当有了这个引用之后我们就可以操作这个内存了!太帮了!打一个比方,就好像我们遛狗一样,我们需要一条绳子,套住我们的爱犬!然后你才能放心的去遛狗。好了!当我们创建这样一个对象的时候,FLASH会做什么呢?

先说第一个吧!它的名字叫做“引用计数法”,从名字我们就可以看出来,当一个内存对象添加了一个引用的时候,这个计数器就加1,当删除一个内存对象的引用时,该计数器就减1.当FLASH程序判断,计数器为0的时候,那么表示,这个对象已经么有引用了,没有引用就没办法控制他了,马上删除。这样就OK了!怎么样,这个设计不错吧!想法很好,思路简单。但有一种情况就麻烦了!注意,当有多个对象互相引用的时候,所有的计数器始终为1,这时就出现了内存泄露的情况。该内存确实没用了!但是呢,垃圾回收机却不清理它!郁闷,如果你的机器是512M内存的话。。。。。可想而知,这个办法在一般情况下还是不错的!但是遇到这种情况就OVER了!~那还有第二种方法吗?YES!放心,我们还有第二手准备,它的名字叫“标识清除法”。

这个方法在执行的时候会从FLASH的跟对象也就是root开始到每一个引用的对象做标识。好了!这是第一步,然后FLASH会遍历当前程序中的所有引用,发现没有标识的对象就清除。这样的话清除就准确了!但是会遇到一个问题。遍历是很消耗CPU的,虽然fp9通过调整迭代标识清除缩减对CPU的占用,但是消耗依然很大!所以采用了另外一种比较消极的处理方法!就是分段执行,每次执行一部分,然后偶尔执行一次。这样来减小CPU的消耗。所以我们通常知道,FP9、10的垃圾回收机是偶尔执行的!这也是比较麻烦的一个地方!具体麻烦在什么地方我们下次讨论!

六、AS3 内存释放优化原则

1. 被删除对象在外部的所有引用一定要被删除干净才能被系统当成垃圾回收处理掉;

2. 父对象内部的子对象被外部其他对象引用了,会导致此子对象不会被删除,子对象不会被删除又会导致了父对象不会被删除;

3. 如果一个对象中引用了外部对象,当自己被删除或者不需要使用此引用对象时,一定要记得把此对象的引用设置为null;

4. 本对象删除不了的原因不一定是自己被引用了,也有可能是自己的孩子被外部引用了,孩子删不掉导致父亲也删不掉;

5. 除了引用需要删除外,系统组件或者全局工具、管理类如果提供了卸载方法的就一定要调用删除内部对象,否则有可能会造成内存泄露和性能损失;

6. 父对象立刻被删除了不代表子对象就会被删除或立刻被删除,可能会在后期被系统自动删除或第二次移除操作时被删除;

7. 如果父对象remove了子对象后没有清除对子对象的引用,子对象一样是不能被删除的,父对象也不能被删除;

8. 注册的事件如果没有被移除不影响自定义的强行回收机制,但有可能会影响正常的回收机制,所以最好是做到注册的事件监听器都要记得移除干净。

9. 父对象被删除了不代表其余子对象都删除了,找到一种状态的泄露代码不等于其他状态就没有泄露了,要各模块各状态逐个进行测试分析,直到测试任何状态下都能删除整个对象为止。

七、as3 内存回收机制测试

通过编写测试程序发现以下规律,flash内存回收机制的一些特点:

1.自动内存回收时间不确定。

2.当一个对象存在被其他对象引用时,这个对象不会被内存回收。

3.当一个流对象被加载,这个被加载的对象及已经占用了内存。

4.当一个可视化对象被声明,但没有添加到画面是占用部分内存,加到displayObject上后,占用全部该对象对象全部内存。

5.当加载重复对象,例如加载100个同样的 XX.swf ,如果仅是加载,完成后没有引用,那么内存变化规律,波浪型的。如果某个时间内存回收。那么最后留在内存中的应该是大小近似于加载1个 XX.swf (比1个XX.swf 要大些),从此可以推理出,要是不同的东西被加载,那么最后即便是没有内存漏洞,在一定条件下常用的东西内存中可能也会至少保存每一个不同的东西。经我测试好像是这样的。(测多了可能还会有新发现呢)

6.引用的包括

1)对对象的存储:例如使用一个数组保存某些对象,那么数组不释放,对象不可能释放

2)对事件的监听:例如监听过程实际上是使用一个对象保存关键字和关键字关联的事件,对事件关键字,查找然后找出对应的关联function。以下是as2代码。As3 的EventDispatcher功能类似

var btnListener:Object = new Object();

btnListener.click = function() {

trace("haha")

};

bt1.addEventListener("click", btnListener);

使用removerEventer 方法定是要清除掉处理关键字索引和function 的对象。这样即清除掉了计数引用。

3)强制回收方式,自动内存回收时间不确定,使用特殊的方法,该方法实际上触发一个错误引起资源回收,使无用的不被计数器引用的都要被回收。(暂时不被使用的,没有引用的那个被自动回收保留的那个一个回收掉)

方法:

try {

trace("force a GC");

new LocalConnection().connect('foo');

new LocalConnection().connect('foo');

} catch (e:Error) {

trace(e.message);

}

}

一个例子假如有个loader 请求加载url=xxxx.swf 的地址,然后成功加载 xxxx.swf, 10次,每次成功后没有处理,假设这时候自动回收没有调用,那么使用强制回收,在debug模式下,会看到回收资源。

[Unload SWF] xxxx.swf ,10个这样的输出。

7.编写代码注意:

1)无用的对象,没有引用

2)降低类设计之间的耦合度,注意对象传递引用的设计等

3)单例模式,在合适的时候使用

4)事件循环嵌套造成多次执行,或事件触发循环bug。

5)对象重复加同样的监听

根据内存特性制作了资源管理类模块

monitor XML 文件

1.客户端根据主配置文件加载相关模块配置文件,其中之一模块就是monitor xml文件

在编译发布客户端时,可以不包括此文件,在开发人员使用时可以包括此文件,监视客

户端运行情况,那么这样有助于使用更少的类,节省资源。

依赖于XML配置体系的修改,打算客户端重构后实现。

Resource Monitor 资源监视类

资源监视,主要利用弱引用,监视对象是否存在,对象加载的资源大小可以获得,同过对象是否存在来统计该所有对象资源大小总和。

统计过程中需要对资源类型划分,这里涉及到类型如何划分,以及改造过程中如何传递这些资源的类型。因为具体改造就是通过一个公用函数获取资源,那么就需要告诉这个函数,什么地方(模块)用,以便统计。

工作量分布 1编写Resource Monitor类,2修改代码中所有资源加载处。

有一点需要注意,这次添加Resource Monitor类的方式,在以后重构后,加载调用的函数方

式可能都需要改变,设想通过服务来获取资源。那么这个服务的名称等信息自然会得到。使用方法

weeklyLoader = new Loader();//程序中的loader加载 ,不需要改变

RF.load(weeklyLoader,path,"人物图片");//添加 RF 为资源管理类,采用静态方法访问,path 是资源的url,”人物图片”是模块或资源类型的名称。不需要传递回调方法。

八、AS3内存优化13条

1. 使用合适的显示对象,对于非交互的简单形状用Shape对象,对于不需要时间轴的交互式对象用Sprite,对于使用时间轴的动画用MovieClip,他们的内存使用量分别是236,412,440,可见shape很省内存

(小焱补充:Sprite相当于静态图片,MovieClip相当于动态图片,因为是动态的所以带时间轴,对于始终静止的对象还是建议使用Sprite)

2. Number原始存储内存占8个字节,int,uint,Boolean,String均占4个字节, 关于赋值后作占内存,取决值赋的值

(小焱补充:这个对于任何编程语言都是一样的,不同的变量初始化的时候内存是不一样的,比如你一个100以下的数字声明为int就比声明为number要省4个字节,但是AS和编译型语言不一样,他会根据赋值来自动更改)

3. 对象的重复利用, 在FOR循环内new对象要小心,每次new都会增大内存。

(小焱补充:AS中内存增加是因为new,而不是addChild,而removeChild并没有真正删除一个元件,而是仅仅删除元件的索引,所以内存并不会减少,遗憾的是AS并没有类似Free这样的方法去强制释放内存,只能根据其垃圾回收机制自动释放)

4. 通过重复使用 BitmapData 对象可以节省更多的内存,即不同的bitmap公用一个bitmapdata

5. 重复使用相同对象的时候,可以考虑下对象池的应用

6. 垃圾回收运行时会不断检测出处于非活动状态的对象,大型项目中此进程会占用大量CPU,所以尽量重使用对象,不用的对象设置为NULL

(小焱补充:对于removeChild的对象,最好再加上一句“对象= NULL”,注意NUll和null是不一样的,NULL表示一个空对象,而null表示一个空字符,空变量等等)

7. 内存释放方面,为了确保被垃圾回收,首先保证该对象没有其他引用,然后移除监听,在然后设置为NULL。关于bitmapdata, 先用dispose 在设置为null

(小焱补充:关于addEventListener,他最后一个参数设置为true,表示弱引用,这样即使没用removeEventListener也会在一定时间后被系统垃圾回收机制自动删除,这个时间表示为该侦听器持续没有监听到事件的时间)

8. 在Flash Player 10.1 中,对所有bitmapdata实例采用同一版本的bitmapdata, 大大节省了内存, 当bitmapdata数据发生变化的时候,内存中会建立一个新的bitmapdata实例

(小焱补充:FlashPlayer 10后续版本做了大量的内存优化)

9. 尽量避免使用滤镜,当对显示对象使用滤镜的时候,内存中将创建两个位图,每个位图的大小都与显示对象相同。一个是显示对象的栅格化版本,一个是用于滤镜的位图

10. 当修改滤镜的属性的时候,内存中两个位图都将更新创建新的位图,会消耗一些CPU,并且会占用大量内存。

11. Flash Player 10.1 在所有平台上引入了一种新的过滤行为。如果滤镜在 30 秒内没有进行修改,或者将其隐藏或置于屏幕之外,将释放未过滤的位图占用的内存。该方式成为动态位图卸载。

12. 使用滤镜时仍要谨慎小心;在对它们进行修改时,仍要求大量 CPU 或 GPU 处理。

13. 如果想要滤镜效果,最好用PHOTOSHOP来做一个

(小焱补充:的确,对于使用代码生成的效果肯定比直接带效果的图片要更加耗费资源,所以,能使用PS处理的效果就不要交给AS代码来做)

九、AS3的垃圾回收机制详解

AS3相对于以前版本的功能增强了很多,在赋予它重任时,同时也要它付出代价:垃圾收集器不再支持自动为你收集垃圾。本文中,我为大家整理了一些资料。首先,我们先来了解下垃圾收集器是个什么东西?

(1)关于垃圾收集器

垃圾收集器是一个后台进程它负责回收程序中不再使用的对象占用的内存。非活动对象就是不再有任何其他活动对象引用它。为便于理解这个概念,有一点非常重要,就是要意识到除了非原生类型(Boolean, String, Number,uint, int除外),你总是通过一个句柄访问对象,而非对象本身。当你删除一个变量其实就是删除一个引用,而非对象本身。

(2)AS3的内存机制的方法:

引用计数法:引用计数法是一种用于跟踪活动对象的较为简单的方法,它从ActionScript1.0开始使用。当你创建一个指向某个对象的引用,该对象的引用计数器加1;当你删除该对象的一个引用,该计数器减1.当某对象的计数器变成0,该对象将被标记以便垃圾回收器回收。

var a:Objec t = {foo:”bar”}

// the object now has a reference count of 1 (a)

var b:Object = a;

// now it has a reference count of 2 (a & b)

delete(a);

// back to 1 (b)

delete(b);

// down to 0, the object can now be deallocated by the GC

引用计数法简单,它不会非CPU带来巨大的负担;多数情况下它工作正常。不幸地是,采用引用计数法的垃圾回收器在遇到循环引用时效率不高。循环引用是指对象交叉引用(直接、或通过其他对象间接实现)的情况。即使应用程序不再引用该对象,它的引用计数器仍然大于0,因此垃圾收集器永远无法收集它们。下面的代码演示循环引用:

var a:Object = {}

// create a second object, and reference the first object:

var b:Object = {foo:a};

// make the first object reference the second as well:

a.foo = b;

// delete both active application references:

delete(a);

delete(b);

上述代码中,所有应用程序中活动的引用都被删除。我没有任何办法在程序中再访问这两个对象了,但这两个对象的引用计数器都是1,因为它们相互引用。循环引用还可以更加负责(a 引用 c, c引用b, b引用a,等等)并且难于用代码处理。FlashPlayer 6 和 7的XML对象有很多循环引用问题:每个 XML 节点被它的孩子和父亲引用,因此它们从不被回收。幸运的是FlashPlayer 8 增加了一个叫做标识-清除的新垃圾回收技术。

标识-清除法 ActionScript3.0 (以及FlashPlayer 8)垃圾回收器采用第2种策略标识-清除法查找非活动对象。FlashPlayer从你的应用程序根对象开始(ActionScript3.0中简称为root)直到程序中的每一个引用,都为引用的对象做标记。接下来,FlashPlayer遍历所有标记过的对象。它将按照该特性递归整个对象树。并将从一个活动对象开始能到达的一切都标记。该过程结束后,FlashPlayer可以安全的假设:所有内存中没有被标记的对象不再有任何活动引用,因此可以被安全的删除。图1 演示了它如何工作:绿色引用(箭头)曾被FlashPlayer 标记过程中经过,绿色对象被标记过,白色对象将被回收。

(3)AS3的内存机制的特点:

1.自动内存回收时间不确定。

2.当一个对象存在被其他对象引用时,这个对象不会被内存回收。 3.当一个流对象被加载,这个被加载的对象及已经占用了内存。 4.当一个可视化对象被声明,但没有添加到画面是占用部分内存,加到displayObject上后,占用全部该对象对象全部内存。

5.当加载重复对象,例如加载100个同样的 XX.swf ,如果仅是加载,完成后没有引用,那么内存变化规律,波浪型的。如果某个时间内存回收。那么最后留在内存中的应该是大小近似于加载1个 XX.swf (比1个XX.swf 要大些),从此可以推理出,要是不同的东西被加载,那么最后即便是没有内存漏洞,在一定条件下常用的东西内存中可能也会至少保存每一个不同的东西。经我测试好像是这样的。(测多了可能还会有新发现呢)

6.引用的包括

1)对对象的存储:例如使用一个数组保存某些对象,那么数组不释放,对象不可能释放

2)对事件的监听:例如监听过程实际上是使用一个对象保存关键字和关键字关联的事件,对事件关键字,查找然后找出对应的关联function。以下是as2代码。

3)强制回收方式,自动内存回收时间不确定,使用特殊的方法,该方法实际上触发一个错误引起资源回收,使无用的不被计数器引用的都要被回收。(暂时不被使用的,没有引用的那个被自动回收保留的那个一个回收掉),附件为强制回收类。

7.编写代码注意:

1)无用的对象,没有引用

2)降低类设计之间的耦合度,注意对象传递引用的设计等

3)单例模式,在合适的时候使用

4)事件循环嵌套造成多次执行,或事件触发循环bug。

5)对象重复加同样的监听

(4)AS3开发需要注意的地方:

1. 被删除对象在外部的所有引用一定要被删除干净才能被系统当成垃圾回收处理掉;

2. 父对象内部的子对象被外部其他对象引用了,会导致此子对象不会被删除,子对象不会被删除又会导致了父对象不会被删除;

3. 如果一个对象中引用了外部对象,当自己被删除或者不需要使用此引用对象时,一定要记得把此对象的引用设置为null;

4. 本对象删除不了的原因不一定是自己被引用了,也有可能是自己的孩子被外部引用了,孩子删不掉导致父亲也删不掉;

5. 除了引用需要删除外,系统组件或者全局工具、管理类如果提供了卸载方法的就一定要调用删除内部对象,否则有可能会造成内存泄露和性能损失;

6. 父对象立刻被删除了不代表子对象就会被删除或立刻被删除,可能会在后期被系统自动删除或第二次移除操作时被删除;

7. 如果父对象remove了子对象后没有清除对子对象的引用,子对象一样是不能被删除的,父对象也不能被删除;

8. 注册的事件如果没有被移除不影响自定义的强行回收机制,但有可能会影响正常的回收机制,所以最好是做到注册的事件监听器都要记得移除干净。

9. 父对象被删除了不代表其余子对象都删除了,找到一种状态的泄露代码不等于其他状态就没有泄露了,要各模块各状态逐个进行测试分析,直到测试任何状态下都能删除整个对象为止。

(5)内存泄露举例:

1. 引用泄露:对子对象的引用,外部对本对象或子对象的引用都需要置null;

2. 系统类泄露:使用了系统类而忘记做删除操作了,如BindingUtils.bindSetter(),ChangeWatcher.watch()函数时候完毕后需要调用ChangeWatcher.unwatch()函数来清除引用,否则使用此函数的对象将不会被删除;类似的还有MUSIC,VIDEO,IMAGE,TIMER,EVENT,BINDING等。

3. 效果泄露:当对组件应用效果Effect的时候,当本对象本删除时需要把本对象和子对象上的Effect动画停止掉,然后把Effect的target对象置null; 如果不停止掉动画直接把 Effect置null将不能正常移除对象。

4. SWF泄露:要完全删除一个SWF要调用它的unload()方法并且把对象置null;

5. 图片泄露:当Image对象使用完毕后要把source置null;(为测试);

6. 声音、视频泄露: 当不需要一个音乐或视频是需要停止音乐,删除对象,引用置null;

附件为强制回收类。调用方法:

import MyGc;

MyGc.GC()

强制回收类

原创文章如转载,请注明:转载自FLEX开发乐园 [ https://www.360docs.net/doc/f610882542.html,]

另外写一写自己看到的强制垃圾回收方式:

核心代码:

try{

new LocalConnection().connect("MoonSpirit");

new LocalConnection().connect("MoonSpirit");

}catch(error : Error){

}

另外关于为什么用LocalConnection方式的解释是

其实LocalConnection与垃圾回收是没有直接关系的.

这个做法的原理在于垃圾回收的时间尽管不确定,但是,只要程序抛出错误,就会运行一次垃圾回收器.这里使用LocalConnection两次connect同一个连接,第二次将发生运行时错误(#1034,LocalConnection已经连接上).于是就报错了.垃

圾回收器自动运行.

至于为什么网上流传的版本都是LocalConnection,我个人觉得,可能是因为这

个LocalConnection在AS3的应用中相对比较少出现,而且跟其他代码相比,这个运行时错误不容易与其他代码发生冲突.

用try catch就可以让错误静默失败,既屏蔽了错误,又调用了垃圾回收。学习~~

十、flash as3 内存管理和资源管理

资源管理:

1、资源的回收,当发现没有引用者(unload而且没有相关的事件-such as listener-关联)后,会在下一次GC马上回收

2、因为需要GC下一次回收才能清理,并且没有任何方法卸载掉swf,所以界面不应该同时load入多个swf(对UI的设计有要求)

3、如果和当前的stage产生了关系(如鼠标事件和键盘事件的监听)且该关系不是弱引用的swf,则无法清理,只有退出了stage才能清理

资源回收管理的建议:

1、使用System.totalMemory进行检测(如果全部都是自己开发的swf可用flex builder的profile)

2、使用weak reference来设置listener

十一、轻松几行让你AS3程序不再“内存泄露

最近貌似大家很喜欢“内存回收”这东西

老实说,这东西不管也罢…它有机会就会回收的,强制内存回收也是用来玩玩而已

但是,有一个和内存回收无关的东西--程序设计上导致的内存占用不断上升,这点是靠我们经验来解决,而不是靠那个所谓的内存回收机制。

如果你觉得这文很长,直接看后面…

怎么样编写内存占用少的AS3程序?我经验不足怎么办?

正所谓的,看代码,就是和其他程序员的心灵的交流,所以下面我就无耻地请出我们的代码了。

请大家定位到Flex3InstallRoot\sdks\3.0.0\frameworks\projects\framework\src\mx\mana gers\PopUpManagerImpl.as中,看看人家究竟是怎么个设计。

大家请先看

public function addPopUp 这个函数

里面一对代码都是关于如何在PopupManager中创建一个弹出窗口的代码,其中有一点很值得重视…

// Listen for unload so we know to kill the window (and the modalWindow if modal)

// this handles _all_ cleanup

window.addEventListener(Event.REMOVED, popupRemovedHandler);

复制代码

就是在这里,PopupManager给添加了个Remove事件的监听器。

跟着,如果我们要去除这个PopUp的时候是调用RemovePopup的,我们看看这个函数是怎么写的:

public function removePopUp(popUp:IFlexDisplayObject):void

{

// all we want to do here is verify that this popup is one of ours

// and remove it from the display list; the REMOVED handler will do the rest

// (this is so that we never leak memory, popups will self-manage even if

// removePopUp is not called).

if (popUp && popUp.parent)

{

const o:PopUpData = findPopupInfoByOwner(popUp);

if (o)

{

const sm:ISystemManager = ISystemManager(popUp.parent);

if (o.topMost)

sm.popUpChildren.removeChild(DisplayObject(popUp));

else

sm.removeChild(DisplayObject(popUp));

}

}

}

复制代码

看见开发人员自己写的注释没?他意思是说,当执行removeChild的时候,remove时间会自动触发,来给他们做剩下的清理工作。

跟着我们看看popupRemovedHandler

毫无疑问,它对里面的对象做了一些清理工作,具体就看代码吧......

这个类告诉我们一个很明显的道理:

任何一个DisplayObject被移除的时候都会发出Remove事件,我们只要对这个remove事件进行监听,

再进行相关的清理工作就可以了。

主存空间的分配与回收—首次适应法

主存空间的分配与回收— 首次适应法 This manuscript was revised by the office on December 10, 2020.

南通大学操作系统实验课 实验报告 学生姓名 所在院系 专业 学号 指导教师 南通大学 2014年 5 月 16 日主存空间的分配与回收 ——首次适应法 一、实验目的 主存是中央处理机能直接存取指令和数据的存储器,能否合理而有效地使用它,在很大程度上将影响整个计算机系统的性能。 本实验主要熟悉主存的管理方法以及相应的分配与回收算法。所谓分配,就是解决多道程序或多进程如何共享主存空间的问题,以便各个进程能获得所希望的主存空间,正确运行。所谓回收,就是当进程运行完成时,将其所占用的主存空间归还给系统。 二、实验要求 采用空闲区链法管理空闲区,并增加已分配区表。分配算法采用首次适应法。 三、设计思路: (1)采用空闲区链法管理空闲区,并增加已分配区表。分配算法采用首次适应法(内存空闲区的地址按照从小到大的自然顺序排列),实现内存的分配与回收。 (2)设计一个进程申请序列以及进程完成后的释放顺序,实现主存的分配与回收。

(3)进行分配时应该考虑这样3种情况:进程申请的空间小于、等于或大于系统空闲区的大小。回收时应该考虑这样4种情况:释放区上邻、下邻、上下都邻和都不邻接空闲区。 (4)每次的分配与回收都要求把记录内存使用情况的各种数据结构的变化情况以及各进程的申请、释放情况显示出来。 四、主要思想 (1)输入主存空间的最大长度n创建最大长度总和为n的若干空闲区的主存空闲区链; (2)输入待存作业的长度x,从链头开始找第一个合适作业的空闲区:分区长度小于x时,指针后移,继续寻找;分区长度等于x时,分配空间, 修改作业分区;分区长度大于x时,分配空间,修改分区数据。 五、流程图 1.空闲区链的首次适应算法分配流程图 2.空闲区链的首次适应算法回收流程图 六、调试结果 1.内存的分配 2.内存的回收 3.内存清空 七、总结与感悟 说实话我操作系统学得不是很好,一开始看到题目觉得自己要完成这个实验有些难度。好在老师提醒书上有另一道类似题目的程序代码,另外书上也有首次适应法的流程图,可以给我们一些提示。之后我也参考了网上的相关资料,看看别人是如何实现的,他们都是怎么样的思路和方法,与我一开始的想法相比,比我精妙在哪里。最后自己调试时,遇到了许许多多问题和错误,请教了学得比较好的同学、经过不断的修改和完善之后,终于做完实验。 这次的实验使我了解到,平时对知识的积累相当重要,同时也要注重课上老师的讲解,老师在课上的延伸是课本上所没有的,这些知识对于我们对程序的编写有很大的作用,同时,编程也要求我们有足够的耐心,细细推敲。越着急可能就越无法得到我们想要的结果,遇到不会的问题要多多请教,知识是在实践与向别人请教的过程中积累的,所以问是至关重要的,只要肯下功夫很多东西都是可以完成的。操作系统这门课不但重要而且十分有用,我一定要下功夫把这门课学好。

内存分配与回收

课程设计 题目:主存空间的分配与回收 学生姓名: 学院:信息工程学院 系别:计算机系 专业:计算机科学与技术 班级:计算机 指导教师:副教授 副教授 2011年月日 内蒙古工业大学课程设计任务书(三) 学院(系):信息学院计算机系课程名称:操作系统课程设计指导教师(签名):专业班级:计算机09-2 学生姓名:学号:

目录 第一章背景研究 (1) 1.1课题简介 (1) 1.2 设计要求 (1) 1.3概念原理 (1) 1.4 环境说明和使用工具 (2) 第二章详细设计 (2) 2.1功能介绍 (2) 2.1.1分配函数发fenpei()的执行过程(最佳适应算法) (2) 2.1.2回收进程空间所占的函数free()的执行过程 (2) 2.2函数的规格说明 (3) 2.2.1打印分配表空闲表函数 print() (3) 2.2.2为进程分配空间函数 fenpei(char *c, struct node *p,struct node *f) (3) 2.2.3回收进程所占空间函数struct node * free(char *c, struct node *p,struct node *f) (3) 2.3 主要数据结构 (3) 2.4 流程图 (5) 第三章核心算法的实现 (6) 3.1 分配函数 (6) 3.2回收函数 (11) 第四章测试 (15) 4.1 预测试 (15) 4.2 实际运行结果(截图) (16) 第五章总结 (18) 参考文献 (25)

第一章背景研究 1.1课题简介 操作系统是当代计算机软件系统的核心,是计算机系统的基础和支撑,它管理和控制着计算机系统中的所有软、硬件资源,可以说操作系统是计算机系统的灵魂。操作系统课程是计算机专业学生必须学习和掌握的基础课程, 是计算机应用人员深入了解和使用计算机的必备知识, 是进行系统软件开发的理论基础,也是计算机科学与技术专业的一门理论性和实践性并重的核心主干课程。本课程的目的是使学生掌握现代计算机操作系统的基本原理、基本设计方法及实现技术,具有分析现行操作系统和设计、开发实际操作系统的基本能力。 通过本次课程设计熟悉主存空间的分配与回收,所谓分配,就是解决多道作业或多进程如何共享主存空间的问题。所谓回收,就是当作业运行完成时,将作业或进程所占用的主存空间归还给系统。采用可变式分区管理,使用最佳适应算法实现主存的分配与回收。深入研究此算法有助于我们全面的理解内存的分配原理,培养我们逻辑思维能力。 1.2 设计要求 设计多个作业或进程动态请求内存资源的模拟系统,使用最佳适应算法实现内存的分配与回收,实现可变式分区管理;设计相应的内存分配算法,定义相关数据结构,以及输出显示每次请求分配内存的结果和内存的已分配和未分配的状况。 1.3概念原理 可变式分区管理的原理:区域的大小及起始地址是可变的,根据程序装入时的大小动态地分配一个区域。保证每个区域之中刚好放一个程序。这样可以充分地利用存储空间,提高内存的使用效率。如果一个程序运行完毕,就要释放出它所占有的分区,使之变成空闲区。这样就会出现空闲区与占用区相互交错的情况。这样就需要P 表,F表来分别表示内存的占用区状态与空闲区的状态。

消耗太多内存时回收工作进程

消耗太多内存时回收工作进程: 最大虚拟内存(兆):当工作进程使用的虚拟内存达到设置的值时回收工作进程,默认禁用,如果启用则默认值为500 M;建议设置为不超过虚拟内存总数的70%; 最大使用的内存(兆):当工作进程使用的物理内存达到设置的值时回收工作进程,默认禁用,如果启用则默认值为192 M;建议设置为不超过物理内存总数的60%; 另外需要注意的是,应用程序池具有以下两种工作进程回收方式,不过这两种回收方式均不会造成Web服务的中断: 在空闲此段时间后关闭工作进程(分钟):当工作进程空闲多少分钟后关闭此工作进程,这降低了空闲工作进程对系统资源和CPU性能的消耗,默认启用并且设置为20分钟; 核心请求队列限制为(请求次数):当HTTP.sys接收到某个客户端发送的HTTP请求时,如果处理此请求的对应应用程序池的工作进程还处于忙状态,则HTTP.sys将接收到的请求保存在对应应用程序池的请求队列中,直到工作进程空闲为止。此选项即用于设置此应用程序池的请求队列所能容纳的请求数量,默认情况下每个应用程序池的请求队列限制为保留1000个请求,如果超出则向客户端返回503错误,你可以根据需要适当进行修改,最大可以设置为65535。但是如果设置太大则会消耗大量的系统资源,而设置太小会导致客户端访问时频繁出现503错误。 启用CPU监视:监视此应用程序池的CPU使用率,默认未启用;如果某个应用程序池占用的CPU利用率过多,那么可以通过配置此选项来限制此应用程序池;

最大CPU使用率(百分比):所设置的应用程序池所能使用的最大CPU使用率;启用CPU监视时默认值为100; 刷新CPU使用率(分钟):刷新CPU使用率的间隔时间;启用CPU监视时默认值为5; CPU使用率超过最大使用率时执行的操作:当此应用程序池的CPU使用率超过所设置的最大CPU使用率时所进行的操作,启用CPU监视时默认为无,此时IIS只是在事件日志中进行记录而不进行其他操作;如果选择为关闭,那么IIS将关闭此应用程序池中的所有工作进程; Web园:在Web园中你可以配置此应用程序池所使用的最大工作进程数,默认为1,最大可以设置为4000000;配置使用多个工作进程可以提高该应用程序池处理请求的性能,但是在设置为使用多个工作进程之前,请考虑以下两点: 每一个工作进程都会消耗系统资源和CPU占用率;太多的工作进程会导致系统资源和CPU利用率的急剧消耗; 每一个工作进程都具有自己的状态数据,如果Web应用程序依赖于工作进程保存状态数据,那么可能不支持使用多个工作进程。 性能 在性能标签你可以设置工作进程的运行方式:

C语言中多维数组的内存分配和释放

写代码的时候会碰到多维数组的内存分配和释放问题,在分配和释放过程中很容易出现错误。下面贴上一些示例代码,以供参考。 如果要给二维数组(m*n)分配空间,代码可以写成下面: char **a, i; // 先分配m个指针单元,注意是指针单元 // 所以每个单元的大小是sizeof(char *) a = (char **)malloc(m * sizeof(char *)); // 再分配n个字符单元, // 上面的m个指针单元指向这n个字符单元首地址 for(i = 0; i < m; i++) a[i] = (char *)malloc(n * sizeof(char)); (注意红色部分) 释放应该是: int i; for(i=0;i

a = (char ***)malloc(m * sizeof(char **)); for(i = 0; i < m; ++i) a[i] = (char **)malloc(n * sizeof(char *)); for(i = 0; i < m; ++i) for(j = 0; j < n; ++j) a[i][j] = (char *)malloc(p * sizeof(char)); 释放代码为逆过程,具体代码为: int i,j,; for(i = 0; i < m; ++i) for(j = 0; j < n; ++j) free((void *)a[i][j]); for(i = 0; i < m; ++i) free((void *)a[i]); free((void *)a); 三维以上的多维数组的分配和释放,原理与上面的一样。 (转) C中如何为第二维长度固定的二维数组分配内存

可变分区存储管理方式的内存分配和回收实验报告

一.实验目的 通过编写和调试存储管理的模拟程序以加深对存储管理方 案的理解,熟悉可变分区存储管理的内存分配和回收。 二.实验内容 1.确定内存空间分配表; 2.采用最优适应算法完成内存空间的分配和回收; 3.编写主函数对所做工作进行测试。 三.实验背景材料 实现可变分区的分配和回收,主要考虑的问题有三个:第一,设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计内存分配算法;第三,在设计的数据表格基础上设计内存回收算法。 首先,考虑第一个问题,设计记录内存使用情况的数据表格,用来记录空间区和作业占用的区域。 由于可变分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。由于分区长度不同,因此设计的表格应该包括分区在内存中的起始地址和长度。由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收内存分区时,可能会合并空闲分区,这样如果整个内存采用一张表格记录己分分区和空闲区,就会使表格操作繁琐。分配内存时查找空闲区进行分配,然后填写己分

配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。由此可见,内存的分配和回收主要是对空闲区的操作。这样为了便于对内存空间的分配和回收,就建立两张分区表记录内存使用情况,一张表格记录作业占用分区的“己分分区表”;一张是记录空闲区的“空闲区表”。这两张表的实现方法一般有两种:一种是链表形式,一种是顺序表形式。在实验中,采用顺序表形式,用数组模拟。由于顺序表的长度必须提前固定,所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。它们的长度必须是系统可能的最大项数。 “已分分区表”的结构定义 #definen10//假定系统允许的最大作业数量为n struct {floataddress;//已分分区起始地址 floatlength;//已分分区长度、单位为字节 intflag;//已分分区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名 }used_table[n];//已分分区表 “空闲区表”的结构定义 #definem10//假定系统允许的空闲区最大为m struct {floataddress;//空闲区起始地址

Java 内存释放

Java 内存释放 (问题一:什么叫垃圾回收机制?)垃圾回收是一种动态存储管理技术,它自动地释放不再被程序引用的对象,按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候,内存回收它占领的空间,以便空间被后来的新对象使用,以免造成内存泄露。 (问题二:java的垃圾回收有什么特点?)JAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的,尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收),只能由运行环境提供的一个超级线程进行监测和控制。 (问题三:垃圾回收器什么时候会运行?)一般是在CPU空闲或空间不足时 自动进行垃圾回收,而程序员无法精确控制垃圾回收的时机和顺序等。 (问题四:什么样的对象符合垃圾回收条件?)当没有任何获得线程能访问一个对象时,该对象就符合垃圾回收条件。 (问题五:垃圾回收器是怎样工作的?)垃圾回收器如发现一个对象不能被任何活线程访问时,他将认为该对象符合删除条件,就将其加入回收队列,但不是立即销毁对象,何时销毁并释放内存是无法预知的。垃圾回收不能强制执行,然 而Java提供了一些方法(如:System.gc()方法),允许你请求JVM执行垃圾回收,而不是要求,虚拟机会尽其所能满足请求,但是不能保证JVM从内存中删除所有不用的对象。 (问题六:一个java程序能够耗尽内存吗?)可以。垃圾收集系统尝试在对 象不被使用时把他们从内存中删除。然而,如果保持太多活的对象,系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存,只能保证可用内存尽可能的得到高效的管理。 (问题七:如何显示的使对象符合垃圾回收条件?) (1)空引用:当对象没有对他可到达引用时,他就符合垃圾回收的条件。也就是说如果没有对他的引用,删除对象的引用就可以达到目的,因此我们可以把引用变量设置为null,来符合垃圾回收的条件。 Java代码 1.StringBuffer sb = new StringBuffer("hello");

操作系统之内存分配与回收

操作系统实验 内存的分配与回收 实验报告 一、实验题目:内存的分配与回收 二、实验内容:利用可变分区的首次适应算法,模拟内存的分配与回收。 三、实验目的:掌握可变分区首次适应算法的原理以及其编程实现。 四、实验过程: 1、基本思想:可变分区分配是根据进程的实际需求,动态地为之分配内存空间。首次适应算法要求空闲空间链以地址递增的次序链接。进行内存分配时,从链表头部开始依次检索,找到第一个不小于请求空间大小的空闲空间进行分配。分配时需考虑碎片问题,若分配会导致碎片产生则将整块分区分配。内存的回收需要考虑四种情况:⑴回收分区前后两个分区都空闲,则需要和前后两个分区合并;(2)回收分区只有前一分区空闲,则与前一分区合并;(3)回收分区只有后一分区空闲,则和后一分区合并;(4)回收分区独立,不考虑合并 。 2、主要数据结构: struct FreeArea{ 链结点包含的数据:分区号、大小、起址、标记 i nt ID; i nt size;

l ong address; i nt sign; }; struct Node { 双链表结点结构体:数据区、前向指针、后继指针 F reeArea data; s truct Node *prior; s truct Node *next; }*DLinkList; 3、输入、输出: 输入: I.内存分配时由键盘输入分区ID和大小; II.内存回收时由键盘输入需要回收的分区ID; 输出:输出内存的分配情况(按照地址从低到高) 4、程序流程图:

5、实验结果截屏:

6、源程序代码: #include using namespace std; #define Free 0 //空闲状态 #define Busy 1 //已用状态 #define PBusy 2 //碎片已用状态 #define FINISH 1 //完成 #define FINISH2 1 //完成 #define ERROR 0 //出错 #define memory 512 //最大内存空间为(单位:KB)#define min 10 //碎片最小值(单位:KB) typedef struct FreeArea//空闲链数据 { i nt ID; i nt size; l ong address; i nt sign; }; typedef struct Node//空闲连结构 { F reeArea data;

内存条回收多少钱一个

深圳市锐业电子有限公司https://www.360docs.net/doc/f610882542.html, 深圳市锐业电子有限公司是一家实力雄厚的全球电子元器件库存处理商,针对全球电子贸易商,工厂,代理商的电子元器件库存积压收购。长期收购您剩余的,生产线停产的、产品订单取消等问题而造成库存积压,在这里我们整批采购或单颗采购。我们感兴趣的电子零件包括主动及被动器件,从IC芯片,集成电路,单片机,内存芯片,内存条回收,光耦,CPU到二、三极管、电容、钽电容、电感,插座、晶振等一切电子元器件。我们致力于帮助提高库存周转率和资金利用率,并且降低客户的仓储成本以及管理成本。 回收产品介绍: 1 回收:MacBook Pro、MacBook Air、iMac、iPad、iPhone等苹果全系列产品。 2 回收:联想、戴尔、华硕、宏基、三星、东芝、索尼、惠普、神舟等品牌笔记本。 3 回收:品牌台式电脑、组装DIY电脑、服务器、显示器、一体机电脑等电脑设备。 4 回收:电脑各种配件、CPU、内存条、硬盘、主板、显卡、服务器配件等。 回收对象:公司、个人、企业单位等。上门提货,快捷支付,安全方便. 我们承诺:对所有回收来的电脑硬盘经过专业格式化处理,让您的数

深圳市锐业电子有限公司https://www.360docs.net/doc/f610882542.html, 据更放心,不泄密。 关于价格:我们会派相关专业人员上门,对照市场的行情,为您所处理的电脑物品免费估价, 保证回收价格公道合理。 选择锐业电子的原因: 1、实力雄厚、资金充裕,可以一次性现金收购1000万元以内的库存。 2、全面而专业的评估团队。我们由20多名有数十年经验的评估专家构成,无论IC、内存芯片,三极管、电容,电感等都有专业人员评估,为客户提供一站式服务。 3、快捷的反馈。我们在接到电话的2小时内会给客户回应,并在24小时内报价供客户参考。 4、提供多样化的库存处理解决方案供客户选择。可以统货一次性清仓收购也可以代销。 5、全面而畅通的渠道及全球化的分支机构。我们在深圳、香港均有设点,可以大陆交货也可以香港接货。 6、一切现金交易,无需售后。选择全部在您,风险全部在我! 7、为客户保密,我们承诺不泄露客户的任何信息给第三方。

频繁分配释放内存导致的性能问题分析

内核态与用户态是操作系统的两种运行级别,intel cpu提供Ring0-Ring3三种级别的运行模式。Ring0级别最高,Ring3最低。 当一个任务(进程)执行系统调用而陷入内核代码中执行时,我们就称进程处于内核运行态(或简称为内核态)。此时处理器处于特权级最高的(0级) 内核代码中执行。当进程处于内核态时,执行的内核代码会使用当前进程的内核栈。每个进程都有自己的内核栈。当进程在执行用户自己的代码时,则称其处于用户运行态(用户态)。即此时处理器在特权级最低的(3级)用户代码中运行。 在内核态下CPU可执行任何指令,在用户态下CPU只能执行非特权指令。当CPU处于内核态,可以随意进入用户态;而当CPU处于用户态时,用户从用户态切换到内核态只有在系统调用和中断两种情况下发生,一般程序一开始都是运行于用户态,当程序需要使用系统资源时,就必须通过调用软中断进入内核态。 现象 1 压力测试过程中,发现被测对象性能不够理想,具体表现为: 进程的系统态CPU消耗20,用户态CPU消耗10,系统idle大约70 2 用ps -o majflt,minflt -C program命令查看,发现majflt每秒增量为0,而minflt每秒增量大于10000。 初步分析 majflt代表major fault,中文名叫大错误,minflt代表minor fault,中文名叫小错误。 这两个数值表示一个进程自启动以来所发生的缺页中断的次数。 当一个进程发生缺页中断的时候,进程会陷入内核态,执行以下操作: 检查要访问的虚拟地址是否合法 查找/分配一个物理页 填充物理页内容(读取磁盘,或者直接置0,或者啥也不干) 建立映射关系(虚拟地址到物理地址) 重新执行发生缺页中断的那条指令 如果第3步,需要读取磁盘,那么这次缺页中断就是majflt,否则就是minflt。 此进程minflt如此之高,一秒10000多次,不得不怀疑它跟进程内核态cpu消耗大有很大关系。 分析代码 查看代码,发现是这么写的:一个请求来,用malloc分配2M内存,请求结束后free这块内存。看日志,发现分配内存语句耗时10us,平均一条请求处理耗时1000us 。原因已找到! 虽然分配内存语句的耗时在一条处理请求中耗时比重不大,但是这条语句严重影响了性能。要解释清楚原因,需要先了解一下内存分配的原理。 内存分配的原理 从操作系统角度来看,进程分配内存有两种方式,分别由两个系统调用完成:brk和mmap (不考虑共享内存)。brk是将数据段(.data)的最高地址指针_edata往高地址推,mmap是在进程的虚拟地址空间中(一般是堆和栈中间)找一块空闲的。这两种方式分配的都是虚拟内存,没有分配物理内存。在第一次访问已分配的虚拟地址空间的时候,发生缺页中断,操作系统负责分配物理内存,然后建立虚拟内存和物理内存之间的映射关系。

java垃圾回收机制

上次讲到引用类型和基本类型由于内存分配上的差异导致的性能问题。那么今天就来聊一下和内存释放(主要是gc)有关的话题。 事先声明一下:虽说sun公司已经被oracle吞并了,但是出于习惯,同时也为了偷懒节省打字,以下仍然称之为sun公司。 ★jvm的内存 在java虚拟机规范中(具体章节请看“这里”),提及了如下几种类型的内存空间: ◇栈内存(stack):每个线程私有的。 ◇堆内存(heap):所有线程公用的。 ◇方法区(method area):有点像以前常说的“进程代码段”,这里面存放了每个加载类的反射信息、类函数的代码、编译时常量等信息。 ◇原生方法栈(native method stack):主要用于jni中的原生代码,平时很少涉及。 关于栈内存(stack)和堆内存(heap),已经在上次的帖子中扫盲过了,大伙儿应该有点印象。由于今天咱们要讨论的“垃圾回收”话题,主要是和堆内存(heap)有关。其它的几个玩意儿不是今天讨论的重点。等以后有空了,或许可以单独聊一下。 ★垃圾回收机制简介 其实java虚拟机规范中并未规定垃圾回收的相关细节。垃圾回收具体该怎么搞,完全取决于各个jvm的设计者。所以,不同的jvm之间,gc的行为可能会有一定的差异。下面咱拿sun官方的jvm来简单介绍一下gc的机制。 ◇啥时候进行垃圾回收? 一般情况下,当jvm发现堆内存比较紧张、不太够用时,它就会着手进行垃圾回收工作。但是大伙儿要认清这样一个残酷的事实:jvm进行gc的时间点是无法准确预知的。因为gc启动的时刻会受到各种运行环境因素的影响,随机性太大。 虽说咱们无法准确预知,但如果你想知道每次垃圾回收执行的情况,还是蛮方便的。可以通过jvm的命令行参数“-xx:+printgc”把相关信息打印出来。 另外,调用system.gc()只是建议jvm进行gc。至于jvm到底会不会做,那就不好说啦。通常不建议自己手动调用system.gc(),还是让jvm自行决定比较好。另外,使用jvm命令行参数“-xx:+disableexplicitgc”可以让system.gc()不起作用。 ◇谁来负责垃圾回收? 一般情况下,jvm会有一个或多个专门的垃圾回收线程,由它们负责清理回收垃圾内存。 ◇如何发现垃圾对象? 垃圾回收线程会从“根集(root set)”开始进行对象引用的遍历。所谓的“根集”,就是正在运行的线程中,可以访问的引用变量的集合(比如所有线程当前函数的参数和局部变量、当前类的成员变量等等)。垃圾回收线程先找出被根集直接引用的所有对象(不妨叫集合1),然后再找出被集合1直接引用的所有对象(不妨叫集合2),然后再找出被集合2直接引用的所有对象......如此循环往复,直到把能遍历到的对象都遍历完。 凡是从根集通过上述遍历可以到达的对象,都称为可达对象或有效对象;反之,则是不可达对象或失效对象(也就是垃圾)。 ◇如何清理/回收垃圾? 通过上述阶段,就把垃圾对象都找出来。然后垃圾回收线程会进行相应的清理和回收工作,包括:把垃圾内存重新变为可用内存、进行内存的整理以消除内存碎片、等等。这个过程会涉及到若干算法,有兴趣的同学可以参见“这里”。限于篇幅,咱就不深入聊了。 ◇分代 早期的jvm是不采用分代技术的,所有被gc管理的对象都存放在同一个堆里面。这么做的缺点比较明显:每次进行gc都要遍历所有对象,开销很大。其实大部分的对象生命周期都很短(短命对象),只有少数对象比较长寿;在这些短命对象中,又只有少数对象占用的内存空间大;其它大量的短命对象都属于小对象(很符合二八原理)。 有鉴于此,从jdk 1.2之后,jvm开始使用分代的垃圾回收(generational garbage collection)。jvm把gc相关的内存分为年老代(tenured)和年轻代(nursery)、持久代(permanent,对应于jvm规范的方法区)。大部分对象在刚创建时,都位于年轻代。如果某对象经历了几轮gc还活着(大龄对象),就把它移到年老代。另外,如果某个对象在创建时比较大,可能就直接被丢到年老代。经过这种策略,使得年轻代总是保存那些短命的小对象。在空间尺寸上,年轻代相对较小,而年老代相对较大。 因为有了分代技术,jvm的gc也相应分为两种:主要收集(major collection)和次要收集(minor collection)。主要收集同时清理年老代和年轻代,因此开销很大,不常进行;次要收集仅仅清理年轻代,开销很小,经常进行。 ★gc对性能会有啥影响? 刚才介绍了gc的大致原理,那gc对性能会造成哪些影响捏?主要有如下几个方面: ◇造成当前运行线程的停顿 早期的gc比较弱智。在它工作期间,所有其它的线程都被暂停(以免影响垃圾回收工作)。等到gc干完活,其它线程再继续运行。所以,早期jdk的gc一旦开始工作,整个程序就会陷入假死状态,失去各种响应。

动态内存分配和回收

实验五可变分区存储管理方式的内存分配和回收 一.实验目的 通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉可变分区存储管理的内存分配和回收。 二.实验属性 设计 三.实验内容 1.确定内存空间分配表; 2.采用最优适应算法完成内存空间的分配和回收; 3.编写主函数对所做工作进行测试。 四.实验背景材料 实现可变分区的分配和回收,主要考虑的问题有三个:第一,设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计内存分配算法;第三,在设计的数据表格基础上设计内存回收算法。 首先,考虑第一个问题,设计记录内存使用情况的数据表格,用来记录空间区和作业占用的区域。 由于可变分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。由于分区长度不同,因此设计的表格应该包括分区在内存中的起始地址和长度。由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收内存分区时,可能会合并空闲分区,这样如果整个内存采用一张表格记录己分分区和空闲区,就会使表格操作繁琐。分配内存时查找空闲区进行分配,然后填写己分配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。由此可见,内存的分配和回收主要是对空闲区的操作。这样为了便于对内存空间的分配和回收,就建立两张分区表记录内存使用情况,一张表格记录作业占用分区的“己分分区表”;一张是记录空闲区的“空闲区表”。这两张表的实现方法一般有两种:一种是链表形式,一种是顺序表形式。在实验中,采用顺序表形式,用数组模拟。由于顺序表的长度必须提前固定,所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。它们的长度必须是系统可能的最大项数。 “已分分区表”的结构定义 #define n 10 //假定系统允许的最大作业数量为n struct { float address; //已分分区起始地址 float length; //已分分区长度、单位为字节 int flag; //已分分区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名 }used_table[n]; //已分分区表 “空闲区表”的结构定义 #define m 10 //假定系统允许的空闲区最大为m struct

内存的申请与释放

实习四 主存储器空间的分配和回收 一、实习内容 主存储器空间的分配和回收。 二、实习目的 一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的,通过本实习帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。 三、实习题目 本实习模拟在两种存储管理方式下的主存分配和回收。 第一题:在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收。 [提示]: 可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。例如: 为了 说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下: 第一栏 第二栏 其中,起址——指出一个空闲区的主存起始地址。 长度——指出从起始地址开始的一个连续空闲的长度。 状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区;另一种是“空表目”状态,表示表中对应的登记项目是空白(无效),可用

来登记新的空闲区(例如,作业撤离后,它所占的区域就成了空闲区,应找一个“空表目”栏登记归还区的起址和长度且修改状态)。由于分区的个数不定,所以空闲区说明表中应有适量的状态为“空表目”的登记栏目,否则造成表格“溢出”无法登记。 上述的这张说明表的登记情况是按提示(1)中的例所装入的三个作业占用的主存区域后填写的。 (2) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。为此,在空闲区说明表中,把每个空闲区按其地址顺序登记,即每个后继的空闲区其起始地址总是比前者大。为了方便查找还可使表格“紧缩”,总是让“空表目”栏集中在表格的后部。 (3) 采用最先适应算法(顺序分配算法)分配主存空间。 按照作业的需要量,查空闲区说明表,顺序查看登记栏,找到第一个能满足要求的空闲区。当空闲区大于需要量时,一部分用来装入作业,另一部分仍为空闲区登记在空闲区说明表中。 由于本实习是模拟主存的分配,所以把主存区分配给作业后并不实际启动装入程序装入作业,而用输出“分配情况”来代替。最先适应分配算法如图4-1。 (4) 当一个作业执行结束撤离时,作业所占的区域应该归还,归还的区域如果与其它空闲区相邻,则应合成一个较大的空闲区,登记在空闲区说明表中。例如,在提示(1)中列举的情况下,如果作业2撤离,归还所占主存区域时,应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。归还主存时的回收算法如图4-2。 (5) 请按最先适应算法设计主存分配和回收的程序。然后按(1)中假设主存中已装入三个作业,且形成两个空闲区,确定空闲区说明表的初值。现有一个需要主存量为6K的作业4申请装入主存;然后作业3撤离;再作业2撤离。请你为它们进行主存分配和回收,把空闲区说明表的初值以及每次分配或回收后的变化显示出来或打印出来。 第二题:在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。 [提示]: (1) 分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在主存的空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示图来指出。位示图可由若干存储单元来构成,其中每一位与一个物理块对应,用0/1表示对应块为空闲/已占用。 (2) 假设某系统的主存被分成大小相等的64块,则位示图可用8个字节来构成,另用一单元记录当前空闲块数。如果已有第0,1,4,5,6,9,11,13,24,31,共10个主存

JVM内存分配(栈堆)与JVM回收机制

Java 中的堆和栈 简单的说: Java把内存划分成两种:一种是栈内存,一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。 堆内存用来存放由new创建的对象和数组。 在堆中分配的内存,由Java虚拟机的自动垃圾回收器来管理。 在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊的变量,让栈中这个变量的取值等于数组或对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量。 引用变量就相当于是为数组或对象起的一个名称,以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。 具体的说: 栈与堆都是Java用来在Ram中存放数据的地方。与C++不同,Java自动管理栈和堆,程序员不能直接地设置栈或堆。 Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。 栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。 栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义: int a = 3; int b = 3; 编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3。接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3。这样,就出现了a与b同时均指向3的情况。这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b 的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b, 它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。 String是一个特殊的包装类数据。可以用: String str = new String("abc"); String str = "abc"; 两种的形式来创建,第一种是用new()来新建对象的,它会在存放于堆中。每调用一次就会创建一个新的对象。 而第二种是先在栈中创建一个对String类的对象引用变量str,然后查找栈中有没有存放"abc",如果没有,则将"abc"存放进栈,并令str指向”abc”,如果已经有”abc”则直接令 str指向“abc”。 比较类里面的数值是否相等时,用equals()方法;当测试两个包装类的引用是否指向同一个对象时,用==,下面用例子说明上面的理论。 String str1 = "abc"; String str2 = "abc"; System.out.println(str1==str2); //true

主存空间的分配与回收实验报告

主存空间的分配与回收实验报告

实验报告 课程名称:操作系统 实验名称:主存空间的分配与回收学号: 110310014 学生姓名:于钊 班级:信管1101班 指导教师:吴联世 实验日期: 2013 年12月5日

3、采用最先适应算法(顺序分配算法)分配主存空间。 按照作业的需要量,查空闲区说明表,顺序查看登记栏,找到第一个能满足要求的空闲区。当空闲区大于需要量时,一部分用来装入作业,另一部分仍为空闲区登记在空闲区说明表中。 由于本实验是模拟主存的分配,所以把主存区分配给作业后并不实际启动装入程序装入作业,而用输出“分配情况”来代替。 4、当一个作业执行完成撤离时,作业所占的分区应该归还给系统,归还的分区如果与其它空闲区相邻,则应合成一个较大的空闲区,登记在空闲区说明表中。例如,在上述中列举的情况下,如果作业2撤离,归还所占主存区域时,应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。 2)程序结构(流程图) 首次适应分配模拟算法

主存回收算法 3)实现步骤 实现动态分区的分配与回收,主要考虑三个问题:第一,设计记录主存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计主存分配算法;第三,在设计的数据表格基础上设计主存回收算法。 1.设计记录主存使用情况的数据表格 由于动态分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随主存分配和回收变动。总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。由于分区长度不同,因此设计的表格应该包括分区在主存中的起始地址和长度。由于分配时,空闲区有时会变成两个分区:空闲区和已分分区,回收主存分区时,可能会合并空闲区,这样如果整个主存采用一张表格记录已分分区和空闲区,就会使表格操作繁琐。主存分配时查找空闲区进行分配,然后填写已分配区表,主要操作在空闲区;某个作业执行完后,将该分区贬词空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。由此可见,主存的分配与回收主要时对空闲区的操作。这样为了便于对主存空间的分配与回收,就建立两张分区表记录主存的使用情况:“已分配区表”记录作业占用分区,“空闲区表”记录空闲区。 这两张表的实现方法一般由两种:链表形式、顺序表形式。在本实验中,采用顺序表形式,用数组模拟。由于顺序表的长度必须提前固定,所以无论是“已分配区表”还是“空闲区表”都必须事先确定长度。它们的长度必须是系统可能的最大项数,系统运行过程中才不会出错,因此在多数情况下,无论是“已分配表区”还是“空闲区表”都是空闲栏目。已分配区表中除了分区起始地址、长度

动态内存申请与释放

动态内存申请与释放 (1)malloc方式 申请一维内存时,格式为: 类型表示符*变量名; 变量名= (类型标识符*)malloc(sizeof(类型标识符)*数组大小); 在使用完该方式申请的内存后,必须用free()函数及时释放,格式为:free(变量名) 变量名= NULL; 当申请二维内存时,格式为: 类型标识符**变量名; 变量名= (类型标识符**)malloc(sizeof(类型标识符*)*数组行大小); for(int i=0;i<数组行大小;i++) 变量名[i] = (类型标识符*)malloc(sizeof(类型标识符)*数组列大小);释放格式: free(变量名); 变量名= NULL; (2)new方式 当申请一维内存时,格式为: 类型标识符*变量名; 变量名= new 类型标识符[数组大小];

使用该方式申请的内存后,必须用delete()函数及时释放格式: delete[] 变量名; 变量名= NULL; 当申请二维内存时,格式为: 类型标识符**变量名; 变量名= new 类型标识符*[数组行大小]; for(int i=0;i<数组行大小;i++) 变量名[i] = new 类型标识符[数组列大小]; 释放格式: delete[] 变量名; 变量名= NULL; 例子: 申请二维内存 代码: 1 #include 2 #include 3 using namespace std; 4 5 int main() 6 { 7 int row;

8 int col = 2; 9 cout<<"please input row:"<>row; 11 int **memo; 12 memo = (int **)malloc(sizeof(int*)*row); 13 for(int k=0;k>memo[i][j]; 19 } 20 cout<<"标号——————————————值"<