C#关于继承和内存分配

C#关于继承和内存分配
C#关于继承和内存分配

内存分配的过程:

在此我们以Chicken对象的创建为例,首先是字段,对象一经创建,会首先找到其父类Bird,并为其字段分配存储空间,而Bird也会继续找到其父类Animal,为其分配存储空间,依次类推直到递归结束,也就是完成System.Object内存分配为止。我们可以在编译器中单步执行的方法来大致了解其分配的过程和顺序,因此,对象的创建过程是按照顺序完成了对整个父类及其本身字段的内存创建,并且字段的存储顺序是由上到下排列,object类的字段排在最前面,其原因是如果父类和子类出现了同名字段,则在子类对象创建时,编译器会自动认为这是两个不同的字段而加以区别。

然后,是方法表的创建,必须明确的一点是方法表的创建是类第一次加载到CLR时完成的,在对象创建时只是将其附加成员TypeHandle指向方法列表在Loader Heap 上的地址,将对象与其动态方法列表相关联起来,因此方法表是先于对象而存在的。类似于字段的创建过程,方法表的创建也是父类在先子类在后,原因是显而易见的,类Chicken生成方法列表时,首先将Bird的所有方法拷贝一份,然后和Chicken本身的方法列表做以对比,如果有覆写的虚方法则以子类方法覆盖同名的父类方法,同时添加子类的新方法,从而创建完成Chicken的方法列表。这种创建过程也是逐层递归到Object类,并且方法列表中也是按照顺序排列的,父类在前子类在后,其原因和字段大同小异,留待读者自己体味。

继承的三个关键字:

abstract关键字,是抽象之意。用来限定类时,类中的方法,不能有方法体;用来限定方法时,同样也不能有方法体,并且在子类中除非继续使用抽象方法,否则必须完成方法体。

virtual关键字,是虚之意。简单的用法是用来指示类中的方法可以被子类的同名方法覆盖或者共存。覆盖时,子类中使用override关键字。共存时,使用new 关键字。

new关键字,是新之意。在子类方法中的用法是,用以指示子类中与父类存在的同名方法将在方法表中同父类方法共存,并不覆盖父类的同名方法。这样就达到了多态机制下并非一味覆盖的效果。

理解继承:

继承是可传递的,子类是对父类的扩展,必须继承父类方法,同时可以添加新方法。

—子类可以调用父类方法和字段,而父类不能调用子类方法和字段。

—虚方法如何实现覆写操作,使得父类指针可以指向子类对象成员。

—子类不光继承父类的公有成员,同时继承了父类的私有成员,只是在子类中不被访问。—new关键字在虚方法继承中的阻断作用。

密封类不能被继承(sealed)

Bird bird2=new Chicken();

这种情况下,bird2.ShowType应该返回什么值呢?而bird2.type又该是什么值呢?有两个原则,是.NET专门用于解决这一问题的。

*****************************

1.关注对象原则:调用子类还是父类的方法,取决于创建的对象是子类对象还是父类对象,而不是它的引用类型

2.执行就近原则:对于同名字段或者方法,编译器是按照其顺序查找来引用的,也就是首先访问离它创建最近的字段或者方法

override重写父类的方法,是在地址列表中覆盖了父类方法的地址,所以如果最终运行的是子类的对象,则执行了子类中的方法(因为覆盖了父类方法的地址)(第一个原则)。

new是在子类中定义了与父类同名的方法,要隐藏父类的同名方法,在编译的时候其实是为父类和子类的这两个方法都分配了地址,只不过父类方法排在前面,而子类方法排在后面(先分配父类类型的方法,在分配子类类型的方法)。就近原则根据定义的类型来决定,这样根据就近原则,如果定义的对象类型为父类,则就近找到父类的方法去执行,而如果定义在子

类的类型,则就近找到子类的方法去执行。

*****************************

内存分配:

堆栈内存:

对于分配在堆栈上的局部变量来说,操作系统维护着一个堆栈指针来指向下一个自由空间的地址,并且堆栈的内存地址是由高位到低位向下填充

最后,执行到Main方法的右括号,方法体执行结束,变量x和c的作用域也随之结束,

需要删除变量x和c在堆栈内存中的值,其释放过程和分配过程刚好相反:首先删除c的内存,堆栈指针向上递增2个字节,然后删除x的内存,堆栈指针继续向上递增4个字节,程序执行结

束,此时的内存状况为:

托管堆的内存分配机制:

引用类型的实例分配于托管堆上,而线程栈却是对象生命周期开始的地方。对32位处

理器来说,应用程序完成进程初始化后,CLR将在进程的可用地址空间上分配一块保留的地址空间,它是进程(每个进程可使用4GB)中可用地址空间上的一块内存区域,但并不对应于任何物理内存,这块地址空间即是托管堆。

托管堆又根据存储信息的不同划分为多个区域,其中最重要的是垃圾回收堆(GC Heap)和加载堆(Loader Heap),GC Heap用于存储对象实例,受GC管理;Loader Heap 又分为High-Frequency Heap、Low-Frequency Heap和Stub Heap,不同的堆上又存储不同的信息。Loader Heap最重要的信息就是元数据相关的信息,也就是Type对象,每个Type在Loader Heap上体现为一个Method Table(方法表),而Method Table中则记录了存储的元数据信息,例如基类型、静态字段、实现的接口、所有的方法等等。Loader Heap不受GC控制,其生命周期为从创建到AppDomain 卸载。

TypeHandle,类型句柄,指向对应实例的方法表,每个对象创建时都包含该附加成员,

并且占用4个字节的内存空间。我们知道,每个类型都对应于一个方法表,方法表创建于编译时,主要包含了类型的特征信息、实现的接口数目、方法表的slot数目等。

SyncBlockIndex,用于线程同步,每个对象创建时也包含该附加成员,它指向一块被称为Synchronization Block的内存块,用于管理对象同步,同样占用4个字节的内存空间。

NextObjPtr,由托管堆维护的一个指针,用于标识下一个新建对象分配时在托管堆中所处的位置。CLR初始化时,NextObjPtr位于托管堆的基地址。

,栈的分配是向低地址扩展,而堆的分配是向高地址扩展。

值类型中的引用类型字段和引用类型中的值类型字段,其分配情况又是如何?

这一思考其实是一个问题的两个方面:对于值类型嵌套引用类型的情况,引用类型变量作为值类型的成员变量,在堆栈上保存该成员的引用,而实际的引用类型仍然保存在GC堆上;对于引用类型嵌套值类型的情况,则该值类型字段将作为引用类型实例的一部分保存在GC堆上。在[第八回:品味类型---值类型与引用类型(上)-内存有理]一文对这种嵌套结构,有较详细的分析。对于值类型,你只要记着它总是分配在声明它的地方。

方法保存在Loader Heap的MethodTable中,那么方法调用时又是怎么样的过程?如上文所言,MethodTable中包含了类型的元数据信息,类在加载时会在Loader Heap 上创建这些信息,一个类型在内存中对应一份MethodTable,其中包含了所有的方法、静态字段和实现的接口信息等。对象实例的TypeHandle在实例创建时,将指向MethodTable开始位置的偏移处(默认偏移12Byte),通过对象实例调用某个方法时,CLR根据TypeHandle可以找到对应的MethodTable,进而可以定位到具体的方法,再通过JIT Compiler将IL指令编译为本地CPU指令,该指令将保存在一个动态内存中,然后在该内存地址上执行该方法,同时该CPU指令被保存起来用于下一次的执行。

在MethodTable中,包含一个Method Slot Table,称为方法槽表,该表是一个基于方法实现的线性链表,并按照以下顺序排列:继承的虚方法,引入的虚方法,实例方法和静态方法。方法表在创建时,将按照继承层次向上搜索父类,直到System.Object 类型,如果子类覆写了父类方法,则将会以子类方法覆盖父类虚方法。关于方法表的创建过程,可以参考[第十五回:继承本质论]中的描述。

静态字段的内存分配和释放,又有何不同?

静态字段也保存在方法表中,位于方法表的槽数组后,其生命周期为从创建到AppDomain卸载。因此一个类型无论创建多少个对象,其静态字段在内存中也只有一份。静态字段只能由静态构造函数进行初始化,静态构造函数确保在类型任何对象创建前,或者在任何静态字段或方法被引用前执行,其详细的执行顺序请参考相关讨论。

内存分配与回收

课程设计 题目:主存空间的分配与回收 学生姓名: 学院:信息工程学院 系别:计算机系 专业:计算机科学与技术 班级:计算机 指导教师:副教授 副教授 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表来分别表示内存的占用区状态与空闲区的状态。

动态内存分配和回收

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

C++第七章 动态内存分配习题解答

第七章动态内存分配习题 一、基本概念与基础知识自测题 7.1 填空题 7.1.1 C/C++定义了4个内存区间:(1)、(2)、(3)和(4)。 答案:(1)代码区,存放程序代码; (2)全局变量与静态变量区,存放全局变量或对象(包括静态); (3)局部变量区即栈(stack)区,存放局部变量; (4)动态存储区,即堆(heap)区或自由存储区(free store)。 7.1.2 静态定义的变量和对象用标识符命名,称为(1);而动态建立的称为(2),动 态建立对象的初始化是通过(3)来(4)。 答案:(1)命名对象 (2)无名对象 (3)初始化式(initializer) (4)显式初始化 7.1.4 当动态分配失败,系统采用(1)来表示发生了异常。如果new返回的指针丢失, 则所分配的堆空间无法收回,称为(2)。这部分空间必须在(3)才能找回,这是因为无名对象的生命期(4)。 答案:(1)返回一个空指针(NULL) (2)内存泄漏 (3)重新启动计算机后 (4)并不依赖于建立它的作用域 7.1.5 按语义的缺省的构造函数和拷贝构造赋值操作符实现的拷贝称(1),假设类对象 obj中有一个数据成员为指针,并为这个指针动态分配一个堆对象,如用obj1按成员语义拷贝了一个对象obj2,则obj2对应指针指向(2)。 答案:(1)浅拷贝 (2)同一个堆对象 7.2简答题(以下习题题号可能和教材不一致!) 7.2.1用delete删除p所指向的无名对象时,p指针也同时被删除了,对不对?为什么?答:不对。注意这时释放了p所指向的无名对象占用的内存空间,也就是撤销了该无名对象,称动态内存释放(dynamic memory deallocation),但指针p本身并没有撤销,它仍然存在,该指针所占内存空间并未释放。 7.2.2为什么动态建立类对象数组时,类的定义一定要有缺省的构造函数? 答:new后面类(class)类型也可以有参数。这些参数即构造函数的参数。但对创建数组,没有参数,只能调用缺省的构造函数。 7.2.3要实现深拷贝,自定义的拷贝构造函数应该怎样设计? 答:如果类中有一个数据成员为指针,该类的一个对象中的这个指针p,指向了动态分配的一个堆对象。深拷贝时要给新建立的对象独立分配一个堆对象。这时拷贝的构造函数应

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;

《动态分配内存与数据结构》课后习题

《动态分配内存与数据结构》习题 学号姓名 一、选择题 1、是一种限制存取位置的线性表,元素的存取必须服从先进先出的规则。 A.顺序表B.链表C.栈D.队列 2、是一种限制存取位置的线性表,元素的存取必须服从先进后出的规则。 A.顺序表B.链表C.栈D.队列 3、与顺序表相比,链表不具有的特点是。 A.能够分散存储数据,无需连续内存空间 B.插入和删除无需移动数据 C.能够根据下标随机访问 D.只要内存足够,没有最大长度的限制 4、如果通过new运算符动态分配失败,返回结果是。 A.-1 B.0 C.1D.不确定 5、实现深复制中,不是必须自定义的。 A.构造函数B.复制构造函数 C.析构函数D.复制赋值操作符函数 6、分析下列代码是否存在问题,选择合适的选项:。 int main(void) { int *p = new int [10]; p = new int [10]; delete [] p; p = NULL; return 0; } A.没有问题 B.有内存泄漏 C.存在空悬指针 D.存在重复释放同一空间 7、通过new运算符动态分配的对象,存储于内存中的。 A.全局变量与静态变量区 B.代码区 C.栈区 D.堆区 8、下列函数中,可以是虚函数。 A.构造函数 B.析构函数 C.静态成员函数 D.友元函数 9、关于通过new运算符动态创建的对象数组,下列判断中是错误的。 A. 动态创建的对象数组只能调用默认构造函数 B. 动态创建的对象数组必须调用delete []动态撤销 C. 动态创建的对象数组的大小必须是常数或常变量 D. 动态创建的对象数组没有数组名 10、顺序表不具有的特点是 A. 元素的存储地址连续 B. 存储空间根据需要动态开辟,不会溢出 C. 可以直接随机访问元素 D. 插入和删除元素的时间开销与位置有关 11、假设一个对象Ob1的数据成员是指向动态对象的指针,如果采用浅复制的方式复制该对象得到对象Ob2,那么在析构对象Ob1和对象Ob2时会的问题。 A. 有重复释放 B. 没有 C. 内存泄漏 D. 动态分配失败 12、假设对5个元素A、B、C、D、E进行压栈或出栈的操作,压栈的先后顺序是ABCDE,则出栈的先后顺序不可能是。 A. ABCDE B. EDCBA C. EDBCA D. BCADE 13、假设对4个元素A、B、C、D、E进行压栈或出栈的操作,压栈的先后顺序是ABCD,则出栈的先后顺序不可能是。 A. ABCD B. DCBA C. BCAD D. DCAB 14、通过new运算符动态创建的对象的存放在中。 A. 代码区 B. 栈区 C. 自由存储区 D. 全局数据区 15、链表不具有的特点是。 A. 元素的存储地址可以不连续 B. 存储空间根据需要动态开辟,不会溢出 C. 可以直接随机访问元素 D. 插入和删除元素的时间开销与位置无关 16、有关内存分配和释放的说法,下面当中错误的是 A.new运算符的结果只能赋值给指针变量 B.动态创建的对象数组必须调用delete []动态撤销 C.用new分配的空间位置是在内存的栈区 D.动态创建的对象数组没有数组名 17、关于栈,下列哪项不是基本操作 A.删除栈顶元素 B.删除栈底元素 C.判断栈是否为空 D.把栈置空 18、关于链表,说法错误的是

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一旦开始工作,整个程序就会陷入假死状态,失去各种响应。

C语言的代码内存布局具体解释

一个程序本质上都是由BSS 段、data段、text段三个组成的。这种概念在当前的计算机程序设计中是非常重要的一个基本概念,并且在嵌入式系统的设计中也非常重要,牵涉到嵌入式系统执行时的内存大小分配,存储单元占用空间大小的问题。 ●BSS段:在採用段式内存管理的架构中。BSS段(bss segment)一般是指用 来存放程序中未初始化的全局变量的一块内存区域。 BSS是英文Block Started by Symbol的简称。 BSS段属于静态内存分配。 ●数据段:在採用段式内存管理的架构中,数据段(data segment)一般是指 用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。 ●代码段:在採用段式内存管理的架构中,代码段(text segment)一般是指 用来存放程序执行代码的一块内存区域。这部分区域的大小在程序执行前就已经确定,而且内存区域属于仅仅读。 在代码段中。也有可能包括一些仅仅读的常数变量,比如字符串常量等。 程序编译后生成的目标文件至少含有这三个段。这三个段的大致结构图例如以下所看到的: 当中.text即为代码段,为仅仅读。.bss段包括程序中未初始化的全局变量和static变量。 data段包括三个部分:heap(堆)、stack(栈)和静态数据区。 ●堆(heap):堆是用于存放进程执行中被动态分配的内存段。它的大小并不 固定,可动态扩张或缩减。当进程调用malloc等函数分配内存时。新分配的内存就被动态加入到堆上(堆被扩张);当利用free等函数释放内存时,被释放的内存从堆中被剔除(堆被缩减)

栈(stack):栈又称堆栈,是用户存放程序暂时创建的局部变量,也就是说我们函数括弧“{}”中定义的变量(但不包含static声明的变量。static意味着在数据段中存放变量)。 除此以外,在函数被调用时。其參数也会被压入发起调用的进程栈中。而且待到调用结束后。函数的返回值也会被存放回栈中。 因为栈的先进先出特点,所以栈特别方便用来保存/恢复调用现场。从这个意义上讲,我们能够把堆栈看成一个寄存、交换暂时数据的内存区。 当程序在运行时动态分配空间(C中的malloc函数),所分配的空间就属于heap。其概念与数据结构中“堆”的概念不同。 stack段存放函数内部的变量、參数和返回地址,其在函数被调用时自己主动分配。訪问方式就是标准栈中的LIFO方式。 (由于函数的局部变量存放在此,因此其訪问方式应该是栈指针加偏移的方式,否则若通过push、pop操作来訪问相当麻烦) data段中的静态数据区存放的是程序中已初始化的全局变量、静态变量和常量。 在採用段式内存管理的架构中(比方intel的80x86系统),BSS 段(Block Started by Symbol segment)一般是指用来存放程序中未初始化的全局变量的一块内存区域,一般在初始化时BSS 段部分将会清零。BSS 段属于静态内存分配。即程序一開始就将其清零了。 比方,在C语言之类的程序编译完毕之后,已初始化的全局变量保存在.data 段中,未初始化的全局变量保存在.bss 段中。 text和data段都在可运行文件里(在嵌入式系统里通常是固化在镜像文件里)。由系统从可运行文件里载入;而BSS段不在可运行文件里,由系统初始化。

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

java垃圾回收机制是怎样的

java垃圾回收机制是怎样的 手动管理内存 在介绍现代版的垃圾回收之前,我们先来简单地回顾下需要手 动地显式分配及释放内存的那些日子。如果你忘了去释放内存,那么这块内存就无法重用了。这块内存被占有了却没被使用。这种场景被称之为内存泄露。 下面是用C写的一个手动管理内存的简单例子: intsend_request() { size_tn=read_size(); int*elements=malloc(n*sizeof(int)); if(read_elements(n,elements)

11intsend_request(){size_tn=read_size();stared_ptrelements= make_shared();if(read_elements(n,elements)

c语言中动态内存申请与释放的简单理解

c语言中动态内存申请与释放的简单理解 在C里,内存管理是通过专门的函数来实现的。与c++不同,在c++中是通过new、delete函数动态申请、释放内存的。 1、分配内存 malloc 函数 需要包含头文件: #include 或 #include 函数声明(函数原型): void *malloc(int size); 说明:malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定,void* 类型可以强制转换为任何其它类型的指针。 从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针,并且可以自动计算所需要大小。比如: int *p; p = new int; //返回类型为int* 类型(整数型指针),分配大小为 sizeof(int); 或: int* parr; parr = new int [100]; //返回类型为 int* 类型(整数型指针),分配大小为sizeof(int) * 100; 而 malloc 则必须由我们计算需要的字节数,并且在返回后强行转换为实际类型的指针。 int* p; p = (int *) malloc (sizeof(int)); 第一、malloc 函数返回的是 void * 类型,如果你写成:p = malloc (sizeof(int)); 则程序无法通过编译,报错:“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。 第二、函数的实参为 sizeof(int) ,用于指明一个整型数据需要的大小。如果你写成:

动态内存分配(C语言)

实验报告 实验课程名称:动态内存分配算法 年12月1日

实验报告 一、实验内容与要求 动态分区分配又称为可变分区分配,它是根据进程的实际需要,动态地为之分配内存空间。在实验中运用了三种基于顺序搜索的动态分区分配算法,分别是1.首次适应算法2.循环首次适应算法3.最佳适应法3.最坏适应法分配主存空间。 二、需求分析 本次实验通过C语言进行编程并调试、运行,显示出动态分区的分配方式,直观的展示了首次适应算法循环首次适应算法、最佳适应算法和最坏适应算法对内存的释放和回收方式之间的区别。 首次适应算法 要求空闲分区链以地址递增的次序链接,在分配内存时,从链首开始顺序查找,直至找到一个大小能满足要求的空闲分区为止,然后在按照作业的大小,从该分区中划出一块内存空间,分配给请求者,余下的空余分区仍留在空链中。 优点:优先利用内存中低址部分的空闲分区,从而保留了高址部分的大空闲区,为以后到达的大作业分配大的内存空间创造了条件。 缺点:低址部分不断被划分,会留下许多难以利用的、很小的空闲分区即碎片。而每次查找又都是从低址部分开始的,这无疑又会增加查找可用空闲分区时的开销。

循环首次适应算法 在为进程分配内存空间时,不是每次都从链首开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直到找到一个能满足要求的空闲分区。 优点:该算法能使内存中的空闲分区分布得更均匀,从而减少了查找空闲分区时的开销。 最佳适应算法 该算法总是把能满足要求、又是最小的空闲分区分配给作业,避免大材小用,该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。 缺点:每次分配后所切割下来的剩余部分总是最小的,这样,在存储器中会留下许多难以利用的碎片。 最坏适应算法 最坏适应算法选择空闲分区的策略正好与最佳适应算法相反:它在扫描整个空闲分区或链表时,总会挑选一个最大的空闲区,从中切割一部分存储空间给作业使用。该算法要求,将所有的空闲分区,按其容量以大到小的顺序形成一空闲分区链。查找时,只要看第一个分区能否满足作业要求即可。 优点:可使剩下的空闲区不至于太小,产生碎片的可能性最小,对中小作业有利,同时,最坏适应算法查找效率很高。 缺点:导致存储器中缺乏大的空闲分区 三、数据结构 为了实现动态分区分配算法,系统中配置了相应的数据结构,用以描述空闲分区和已分配分区的情况,常用的数据结构有空闲分区表和空闲分区链 流程图

Php引用计时器和垃圾回收机制

php引用计数器和垃圾回收机制谈到引用计数器和垃圾回收机制,必须得从php变量说起。总所周知,php 是一种弱类型,但具体表现在哪里,程序里面又是怎么表现的呢?php里面又是怎样实现引用计数器的,程序如何区分变量引用和复制?php是如何对已用完的变量进行回收,不同的php版本的不同的垃圾回收机制又是如何实现的? 1.引用计数器 讲到引用计数器,不得不先说一下变量的c语言实现。如下,几个变量的结构体和联合体: zvalue_value联合体: typedef union _zvalue_value { long lval; /* long value */ double dval; /* double value */ struct { char *val; int len; } str; H as hTable *ht; /* hash table value */ zend_object_value obj; } zvalue_value; zval的结构: struct _zval_struct { /* Variable information */ zvalue_value value; /* value */ zend_uint refcount__gc; zend_uchar type; /* active type */ zend_uchar is_ref__gc; }; zval可以看成一个容器,zvalue_value是该容器存储变量值的联合体,refcount__gc 是引用计数,记录引用数,is_ref__gc是标志这个容器是否真正的引用,type表示这个变量的类型。

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

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

long address; int sign; }; struct Node { 双链表结点结构体:数据区、前向指针、后继指针FreeArea data; struct Node *prior; struct 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//空闲链数据 { int ID; int size; long address; int sign; }; typedef struct Node//空闲连结构 { FreeArea data;

C# 内存(垃圾)自动回收机制

基本概念: CLR-所有为.NET编写的程序(包括用C#编写的COM+组件)都运行在称为通用语言运行库(Common Language Runtime,CLR)的环境内。为运行于CLR内编写的应用程序被看作是托管代码。托管代码可利用CLR提供的服务。某些这类服务,如垃圾收集(Garbage Collection), 是自动提供的。其他服务,如对软件的版本编号,则要求程序员干预。 为什么会有垃圾回收机制: 如果我们的内存足够大,大到有无数的连续内存块给我们的应用程序调用,那么垃圾回收机制就很鸡肋了,但实际上是,我们的内存永远无法满足我们应用程序的饥渴的需求,内存越大,应用程序所需求的内存也越大。有那么一部分程序申请了内存(以堆的形式),但是并不是一直在用,用句粗话就是“占着**不**”的意思,为了干掉这么一些个浪费社会资源的存在,内存回收机制的诞生就迫在眉睫了。 程序如何申请内存: CLR启动应用程序时创建和初始化托管堆。另外,CLR初始化指向堆的基地址的堆指针。堆指针包含下一个可用内存块的地址。图1—1展示了初始化后且在创建任何对象之前的托管堆。 当在C#中用关键词new 创建对象时,CLR 从堆分配内存并将堆指针增加使之指向下一个可 用的内存块。图1-2 显示了应用程序中首次调用new 后的堆。

CLR 从托管堆分配内存可以比从传统非托管的Win32 堆分配内存快得多。在典型非托管的Win32 堆中,内存的分配不是顺序的。当从Win32 堆分配内存时,堆必须检查以寻找满足请示的内存块。一旦找到内存块,堆维护的数据结构就必须更新。另一方面,托管堆则只需增加堆指针。 开始垃圾回收: 在某些时候,堆指针增加到了堆的顶部,不再有内存可供分配。出现这种情况时,一种被称为垃圾收集(Garbage Collection)的过程开始释放不再使用的资源。垃圾收集(Garbage Collection)以构建应用程序正在使用的所有对象的列表为开始。垃圾收集器查找的开始之处事应用程序的根,其中包括: * 全局对象引用 * 静态对象引用 * 局部变星(对当前正在执行的方法而言) * 参数(对当前正在执行的方法而言) * 包含对象引用的CPU寄存器 应用程序根的整个列表由允许垃圾收集器向运行库查询的JIT编译器加以维护。一旦识别出根的整个列表,垃圾收集器就访问每个根的每一个对象引用。如果根包含对其他对象的引用,也会将这些引用加入到列表中。一旦垃圾收集器已经访问整个对象引用链,就检查堆栈以查找末在列表中的任何引用。不在列表中的引用被视为不能访问并可以释放。释放不能访问对象所占的内存后,垃圾收集器就压缩堆并将堆指针设为堆的下一个可用块。 到这里可能会引起怀疑:前面辛辛苦苦创建的内存自动分配的速度和性能优势,通过这样的垃圾搜集机制不是都浪费了吗?嘿嘿,这还不是事情的全部。垃圾收集器使用一种称为通用垃圾收集(Generational Garbage Collection)的技术优化垃圾收集过程。通用垃圾收集假定关于应用应用程序的以下情况为真: * 新对象有比旧对象短的寿命

相关文档
最新文档