精华内容
下载资源
问答
  • 创建一个对象都在内存中做了什么事情?1:先将硬盘上指定位置的Person.class文件加载进内存。2:执行main方法时,在栈内存中开辟了main方法的空间(压栈-进栈),然后在main方法的栈区分配了一个变量p。3:在堆内存中...
    创建一个对象都在内存中做了什么事情?

    1:先将硬盘上指定位置的Person.class文件加载进内存。
    2:执行main方法时,在栈内存中开辟了main方法的空间(压栈-进栈),然后在main方法的栈区分配了一个变量p。
    3:在堆内存中开辟一个实体空间,分配了一个内存首地址值。new
    4:在该实体空间中进行属性的空间分配,并进行了默认初始化。
    5:对空间中的属性进行显示初始化。
    6:进行实体的构造代码块初始化。
    7:调用该实体对应的构造函数,进行构造函数初始化。()
    8:将首地址赋值给p ,p变量就引用了该实体。(指向了该对象)

    从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的,栈主要是用来执行程序的.


    转载于:https://www.cnblogs.com/xuedexin/p/5690206.html

    展开全文
  • 本文主要通过分析Java内存分配的栈、堆以以及常量池详细的讲解了其的工作原理。下面w我来讲解下java虚拟机内存原型是什么?Java内存工作原理是什么? java虚拟机内存原型是什么 寄存器:我们在程序中无法控制栈:...

    本文主要通过分析Java内存分配的栈、堆以以及常量池详细的讲解了其的工作原理。下面w我来讲解下java虚拟机内存原型是什么?Java内存工作原理是什么?

    java虚拟机内存原型是什么

    寄存器:我们在程序中无法控制栈:存放基本类型的数据和对象的引用,但对象本身不存放在栈中,而是存放在堆中堆:存放用new产生的数据静态域:存放在对象中用static定义的静态成员常量池:存放常量非RAM存储:硬盘等永久存储空间。

    常量池(constantpool)

    常量池指的是在编译期被确定,并被保存在已编译的。class文件中的一些数据。除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值(final)还包含一些以文本形式出现的符号引用,比如:

    1、类和接口的全限定名;

    2、字段的名称和描述符;

    虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和,包括直接常量(string,integer和floatingpoint常量)和对其他类型,字段和方法的符号引用。对于String常量,它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的,对于String类型,有一张固定长度的CONSTANT_String_info表用来存储文字字符串值,注意:该表只存储文字字符串值,不存储符号引用。说到这里,对常量池中的字符串值的存储位置应该有一个比较明了的理解了。在程序执行的时候,常量池会储存在MethodArea,而不是堆中。

    Java内存工作原理是什么

    java虚拟机中的堆用来存放由new创建的对象和数组。在堆中分配的内存,由Java虚拟机的自动的垃圾回收机制来管理堆的内存。简单的说和栈相对,堆主要是用来存放java对象的,栈主要是用来存放对象引用的…在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊的变量,让栈中这个变量的取值等于数组或对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称,以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。

    引用变量是普通的变量,定义时在栈中分配,引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配,即使程序运行到使用new产生数组或者对象的语句所在的代码块之外,数组和对象本身占据的内存不会被释放,数组和对象在没有引用变量指向它的时候,才变为垃圾,不能在被使用,但仍然占据内存空间不放,在随后的一个不确定的时间被垃圾回收器收走(释放掉)。这也是Java比较占内存的原因。实际上,栈中的变量指向堆内存中的变量,这就是Java中的指针!

    Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。

    栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。栈中主要存放一些基本类型的变量数据(int,short,long,byte,float,double,boolean,char)和对象句柄(引用)。

    栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:

    inta=3;intb=3;编译器先处理inta=3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3.接着处理intb=3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3.这样,就出现了a与b同时均指向3的情况。

    这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。

    要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b,它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。

    以上就是关于“java虚拟机内存原型是什么?Java内存工作原理是什么”的内容,希望对大家有用。更多资讯可以进入Java学习园地 学习更多Java技术知识。

    展开全文
  • 在计算机硬件中,内存指的是cpu运算时,用于暂时存放cpu运算过程中的数据的区域,主要负责从固存中提取cpu运算需要的数据并将cpu运算结果如要保存到固定存储中则保存的一块断电后其所含有的数据便会消失的存储数据...
  • Java内存分配主要包括以下几个区域: 1. 寄存器:我们在程序中无法控制 2. 栈:存放基本类型的数据和对象的引用,但对象本身不存放在栈中,而是存放在堆中 3. 堆:存放用new产生的数据 4. 静态域:存放在对象中用...

    Java内存分配主要包括以下几个区域:

    1. 寄存器:我们在程序中无法控制

    2. 栈:存放基本类型的数据和对象的引用,但对象本身不存放在栈中,而是存放在堆中

    3. 堆:存放用new产生的数据

    4. 静态域:存放在对象中用static定义的静态成员

    5. 常量池:存放常量

    6. 非RAM(随机存取存储器)存储:硬盘等永久存储空间

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

    Java内存分配中的栈

      在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当该变量退出该作用域后,Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。 

    Java内存分配中的堆

      堆内存用来存放由new创建的对象和数组。 在堆中分配的内存,由Java虚拟机的自动垃圾回收器来管理。

       在堆中产生了一个数组或对象后,还可以 在栈中定义一个特殊的变量,让栈中这个变量的取值等于数组或对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称,以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。

      引用变量是普通的变量,定义时在栈中分配,引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配,即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外,数组和对象本身占据的内存不会被释放,数组和对象在没有引用变量指向它的时候,才变为垃圾,不能在被使用,但仍 然占据内存空间不放,在随后的一个不确定的时间被垃圾回收器收走(释放掉)。这也是 Java 比较占内存的原因。 

      实际上,栈中的变量指向堆内存中的变量,这就是Java中的指针! 

    常量池 (constant pool)

      常量池指的是在编译期被确定,并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值(final)还包含一些以文本形式出现的符号引用,比如: 

    1. 类和接口的全限定名;
    2. 字段的名称和描述符; 
    3. 方法和名称和描述符。

      虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和,包括直接常量(string,integer和 floating point常量)和对其他类型,字段和方法的符号引用。

      对于String常量,它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的, 对于String类型,有一张固定长度的CONSTANT_String_info表用来存储文字字符串值,注意:该表只存储文字字符串值,不存储符号引 用。说到这里,对常量池中的字符串值的存储位置应该有一个比较明了的理解了。

      在程序执行的时候,常量池会储存在Method Area,而不是堆中。

    堆与栈

      Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立,它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的,堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态 分配内存,存取速度较慢。 

      栈的优势是,存取速度比堆要快,仅次于寄存器,栈数据可以共享。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。栈中主要存放一些基本类型的变量数据(int, short, long, byte, float, double, boolean, char)和对象句柄(引用)。

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

     

      这里我们主要关心栈,堆和常量池,对于栈和常量池中的对象可以共享,对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的,当没有引用指向数据时,这个数据就会消失。堆中的对象的由垃圾回收器负责回收,因此大小和生命周期不需要确定,具有很大的灵活性。

    字符串内存分配:

      对于字符串,其对象的引用都是存储在栈中的,如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中,如果是运行期(new出来的)才能确定的就存储在堆中。对于equals相等的字符串,在常量池中永远只有一份,在堆中有多份。 

    如以下代码:

            String s1 = "china";
            String s2 = "china";
            String s3 = "china";
    
            String ss1 = new String("china");
            String ss2 = new String("china");
            String ss3 = new String("china");

      这里解释一下黄色这3个箭头,对于通过new产生一个字符串(假设为“china”)时,会先去常量池中查找是否已经有了“china”对象,如果没有则在常量池中创建一个此字符串对象,然后堆中再创建一个常量池中此”china”对象的拷贝对象。

      这也就是有道面试题:Strings=newString(“xyz”);产生几个对象?一个或两个,如果常量池中原来没有”xyz”,就是两个。

      存在于.class文件中的常量池,在运行期被JVM装载,并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法;当一个String实例str调用intern()方法时,Java 查找常量池中是否有相同Unicode的字符串常量,如果有,则返回其的引用,如果没有,则在常量池中增加一个Unicode等于str的字符串并返回它的引用

    如下代码:

            String s0= "kvill";   
            String s1=new String("kvill");   
            String s2=new String("kvill");   
            System.out.println( s0==s1 );     
            s1.intern();   
            s2=s2.intern(); //把常量池中"kvill"的引用赋给s2   
            System.out.println( s0==s1);   
            System.out.println( s0==s1.intern() );   
            System.out.println( s0==s2 ); 

    输出结果:

    false
    false
    true
    true

    String常量池问题的几个例子:

    【1】
    String a = "ab";   
    String bb = "b";   
    String b = "a" + bb;   
    System.out.println((a == b)); //result = false 
    
    【2】
    String a = "ab";   
    final String bb = "b";   
    String b = "a" + bb;   
    System.out.println((a == b)); //result = true 
    
    【3】
    String a = "ab";   
    final String bb = getBB();   
    String b = "a" + bb;   
    System.out.println((a == b)); //result = false   
    private static String getBB() {  
    return "b";   
    } 

    分析:

      【1】中,JVM对于字符串引用,由于在字符串的"+"连接中,有字符串引用存在,而引用的值在程序编译期是无法确定的,即"a" + bb无法被编译器优化,只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。

      【2】和【1】中唯一不同的是bb字符串加了final修饰,对于final修饰的变量,它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。

      【3】JVM对于字符串引用bb,它的值在编译期无法确定,只有在程序运行期调用方法后,将方法的返回值和"a"来动态连接并分配地址为b,故上面程序的结果为false。

    结论:

      字符串是一个特殊包装类,其引用是存放在栈里的,而对象内容必须根据创建方式不同定(常量池和堆).有的是编译期就已经创建好,存放在字符串常 量池中,而有的是运行时才被创建.使用new关键字,存放在堆中。

    基础类型的变量和常量在内存中的分配

      对于基础类型的变量和常量,变量和引用存储在栈中,常量存储在常量池中。

    如以下代码:

            int i1 = 9;
            int i2 = 9;
            int i3 = 9;
    
            final int INT1 = 9;
            final int INT2 = 9;
            final int INT3 = 9;

      编译器先处理int i1 = 9;首先它会在栈中创建一个变量为i1的引用,然后查找栈中是否有9这个值,如果没找到,就将9存放进来,然后将i1指向9。接着处理int i2 = 9;在创建完i2的引用变量后,因为在栈中已经有9这个值,便将i2直接指向9。这样,就出现了i1与i2同时均指向9的情况。最后i3也指向这个9。

    成员变量和局部变量在内存中的分配

      对于成员变量和局部变量:成员变量就是方法外部,类的内部定义的变量;局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。 形式参数是局部变量,局部变量的数据存在于栈内存中。栈内存中的局部变量随着方法的消失而消失。 成员变量存储在堆中的对象里面,由垃圾回收器负责回收。   如以下代码:

    class BirthDate {
        private int day;
        private int month;
        private int year;
    
        public BirthDate(int d, int m, int y) {
            day = d;
            month = m;
            year = y;
        }
        // 省略get,set方法………
    }
    
    public class Test {
        public static void main(String args[]) {
            int date = 9;
            Test test = new Test();
            test.change(date);
            BirthDate d1 = new BirthDate(7, 7, 1970);
        }
    
        public void change(int i) {
            i = 1234;
        }
    }

      对于以上这段代码,date为局部变量,i,d,m,y都是形参为局部变量,day,month,year为成员变量。下面分析一下代码执行时候的变化:    

    1. main方法开始执行:int date = 9; date局部变量,基础类型,引用和值都存在栈中。
    2. Test test = new Test();test为对象引用,存在栈中,对象(new Test())存在堆中。 
    3. test.change(date);  i为局部变量,引用和值存在栈中。当方法change执行完成后,i就会从栈中消失。
    4. BirthDate d1= new BirthDate(7,7,1970); d1为对象引用,存在栈中,对象(new BirthDate())存在堆中,其中d,m,y为局部变量存储在栈中,且它们的类型为基础类型,因此它们的数据也存储在栈中。day,month,year为成员变量,它们存储在堆中(new BirthDate()里面)。当BirthDate构造方法执行完之后,d,m,y将从栈中消失。 
    5. main方法执行完之后,date变量,test,d1引用将从栈中消失,new Test(), new BirthDate()将等待垃圾回收。
    展开全文
  • 一、内存什么要对齐 虽然所有的变量都是保存在特定地址的内存中,但最好还是按照内存对齐的要求来存储。这主要出于两个方面的原因考虑: 平台原因: 不是所有的硬件平台(特别是嵌入式系统中使用的低端处理器)...

    一、内存为什么要对齐

    虽然所有的变量都是保存在特定地址的内存中,但最好还是按照内存对齐的要求来存储。这主要出于两个方面的原因考虑:

    1. 平台原因:
      不是所有的硬件平台(特别是嵌入式系统中使用的低端处理器)都能访问任意地址上的任意数据,某些硬件平台只能访问对齐的地址,否则会出现硬件异常。
    2. 性能原因:
      如果数据存放在未对齐的内存空间中,则处理器访问变量时需要进行两次内存访问才能完整读取该变量的值,而对齐的内存访问仅需一次访问。

    二、内存对齐的规则

    1. 对于结构(或联合)的各个成员,第一个成员位于偏移为0,以后每个数据成员的偏移量必须是#pragma pack指定的数值和结构体(或联合)中最大数据成员长度 这2个数值中较小的一个的倍数。
      使用伪代码表示: min(#pragma pack, 结构最大数据成员长度) * N

    2. 在数据成员完成各自对齐之后,结构(或联合)本身也要进行对齐,对齐也按照#pragma pack指定的数值和结构(或联合)最大数据成员长度这2个数值中较小的一个进行。

    如果没有使用#pragma pack指令来显式的指定内存对齐的字节数,则按照默认字节数来对齐,各个平台的默认对齐规则如下:32位CPU默认按照4字节对齐;64位CPU默认按照8字节对齐。

    三、#pragma pack命令

    #pragma pack(n) // 使用自定义n字节对齐  n可以为1,2,4,8,16
    #pragma pack()  // 使用缺省字节对齐
    #pragma pack(show) // 在编译输出窗口以警告的形式显示出当前的内存以几个字节对齐
    

    四、结构体内存对齐示例

    在64位系统上编译下面的测试程序,已知在64位系统上各类型占用字节数如下:

    char     1字节
    short    2字节
    int      4字节
    long     4字节
    double   8字节
    long long 8字节
    

    示例代码如下:

    #pragma pack(8)
    
    struct A {
    	char s[5];
    	short c;
    	int a;
    };
    
    int main()
    {
    	int i = sizeof(A);
    	printf("%d", i);
    
        return 0;
    }
    

    按照第二节所讲的内存对齐规则,分析如下:
    因为结构体中最大的数据成员长度为int(即4字节),而且#pragma pack(8)指令指定按照8字节对齐,所以min(4,8) = 4,故我们可以知道结构体A按照4字节对齐。

    下图是结构体A按照4字节对齐的内存布局(需要注意的是“内存不是填充在s5后面,而是填充在c后面”):
    这里写图片描述

    从图我们很容易知道sizeof(A) = 12.

    展开全文
  • Java栈内存和堆内存

    2019-12-29 21:09:59
    首先说明栈内存和堆内存存放的是什么内存存放函数中定义的一些基本类型的变量和对象的引用变量; 堆内存存放new创建的对象和数组。 简单的来说,堆主要是用来存放对象的,栈主要是用来执行程序的 这么...
  • 1. 冯·诺依曼计算机设计的主要思想是什么?它包括哪些主要组成部分? 设计思想:数字计算机的数制采用二进制,计算机应该按照程序顺序执行。 主要组成不分: 控制器 、运算器、存储器、输入设备、输出设备五大部分。...
  • 指针变量主要存放相同数据类型的变量的首地址。这里的这个地址其实就是内存的某个字节的编号。而这个编号的确定是与地址总线有关。如果地址总线是32位,则它的寻址范围是0~2^32(0~4G)。所以为一个字节编址就由32...
  • 堆是用于存放对象的内存区域。因此,它是垃圾收集器(GC)管理的主要目标。其具有以下特点: 堆在逻辑上划分为“新生代”和“老年代”。由于JAVA中的对象大部分是朝生夕灭,还有一小部分能够长期的驻留在内存中,...
  • 内存管理和内存泄漏

    2017-05-08 13:37:40
    文章目录一、内存管理1、Java内存分配策略2、Java内存管理3、可达性分析4、四种引用二、内存泄漏1、什么内存泄漏2、常见的内存泄漏1)资源对象未关闭2...静态方法区:主要存放静态static数据和常量。这块内存在程序编
  • 硬盘与内存的区别是很大的,这里只谈最主要的三点: 一、内存是计算机的工作场所,硬盘用来存放暂时不用的信息。 二、内存是半导体材料制作,硬盘是磁性材料制作。 三、内存中的信息会随掉电而丢失,硬盘中的信息...
  • Java中的内存分配区域主要由:堆、栈、常量池、静态域、代码区堆(Heap):堆主要存放Java在运行过程中new出来的对象,凡是通过new生成的对象都存放在堆中,对于堆中的对象生命周期的管理由Java虚拟机的垃圾回收机制GC...
  • Linux根目录下主要目录功能说明 /bin:存放最常用命令; /boot:启动Linux的核心文件; /dev:设备文件; /etc:存放各种配置文件;  /home:用户主目录; /lib:系统最基本的动态链接共享库; ...
  • 什么内存泄漏?大白话讲就是分配出去的内存,...静态的存储区,内存在程序编译的时候就已经分配好了,这块内存在程序整个运行期间都一直存在,它主要存放静态数据、全局的static数据和一些常量。 栈式的 在执行...
  • 内存内存

    2016-12-19 19:39:07
    从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的,栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:  在编程中,例如C/C++中,所有的方法调用都是通过栈来进行的,所有的局部变量,...
  • 内存管理

    2018-03-18 20:54:32
    OC内存管理一、基本原理(一)为什么要进行内存管理。由于移动设备的内存极其有限,所以每个APP所占的内存也是有限制的,...本质原因是因为对象和其他数据类型在系统中的存储空间不一样,其它局部变量主要存放于栈中...
  • 浅谈OC内存管理

    2015-10-08 09:06:11
    一、基本原理 (一)为什么要进行内存管理。 由于移动设备的内存极其有限,所以每个APP所占的内存也是有限制的,当app所占用的...本质原因是因为对象和其他数据类型在系统中的存储空间不一样,其它局部变量主要存放
  • 虚拟内存是一些系统页文件,存放在磁盘上,每个系统页文件大小为4K,物理内存也被分页,每个页大小也为4K,这样虚拟页文件和物理内存页就可以对应,实际上虚拟内存就是用于物理内存的临时存放的磁盘空间。...
  • C语言程序的内存接口简单,内存管理灵活,所以是初学者容易出错的知识,下面就让我们分三篇文章进行讲解,这篇文章主要讲解的是内存管理中的堆与栈。一、堆与栈特点栈:由系统自动分配的释放,用来存放函数的参数、...
  • java 虚拟机主要分为以下一个区:方法区:1. 有时候也成为永久代,在该区内很少发生垃圾回收,但是并不代表不...4. 方法区里有一个运行时常量池,用于存放静态编译产生的字面量和符号引用。该常量池具有动态性,也...
  • boot:200MB swap:8G 根分区:60G(20%左右) 家分区:剩下的全部空间(/home 主要用于存放个人数据,要是服务器用户很多,这个分区得要大) ##理论上:在小于2GB物理内存的系统中,交换分区大小应该设置为内存大小的...
  • 2、新生代中每次使用的空间不超过90%,主要用来存放新生的对象; 3、Minor GC每次收集后Eden区和一块Survivor区都被清空; 4、老年代中使用Full GC,采用的标记-清除算法 类需要同时满足下面3个条件才能算是“无用的...
  • 方法区里有一个运行时常量池,用于存放静态编译产生的字面量和符号引用。该常量池具有动态性,也就是说常量并不一定是编译时确定,运行时生成的常量也会存在这个常量池中 虚拟机栈 虚拟机栈也就是我们平常所称的栈...
  • java内存泄漏问题

    2017-08-20 11:14:15
    主要由这四块内存区域组成,每块内存存放的数据不同,职能也不同 二、堆栈分析 栈 :先进后出 不管在哪里创建的变量或者引用都会存放在栈中,并且在方法执行完或者对象被销毁就会释放栈中的内存,并且每个线程都有...
  • ​ ​内存溢出(Out Of Memory)...Java堆内存主要用来存放运行过程中所有的对象,该区域OOM异常一般会有如下错误信息: java.lang.OutofMemoryError:Java heap space 可以通过dump的内存快照就能分析,到底是由于程序.
  • http://www.importnew.com/14630.htmljava堆的特点《深入理解java虚拟机》是什么描述java堆的Java堆(Java Heap)是java虚拟机所管理的内存中最大的一块java堆被所有线程共享的一块内存区域虚拟机启动时创建java堆java...
  • 《深入理解java虚拟机》是什么描述java堆的 Java堆(Java Heap)是java虚拟机所管理的内存中最大的一块 java堆被所有线程共享的一块内存区域 虚拟机启动时创建java堆 java堆的唯一目的就是存放对象实例。 java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 736
精华内容 294
关键字:

内存主要存放什么