3 java的内存分析

（笔记：编译时就会确定栈内存，但只有运行时才会分配堆内存，换句话说，即编译时，并不会new对象，只有在运行时才会new对象）

一般Java在内存分配时会涉及到以下区域：**

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

  2. 栈：

    1. 每个线程包含一个栈区，栈中只保存基本数据类型的对象和对象的引用(不是对象)，对象都存放在堆区中

    2. 每个栈（栈桢）中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。

  3. 堆：

    1. 存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)

    2. jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身

    3. 即：存放用new产生的数据

  4. 方法区：方法区是系统分配的一个内存逻辑区域，是JVM在装载类文件时，用于存储类型信息的(类的描述信息)。

    1. Class的基本信息：

      1. 每个类的全限定名

      2. 该类是类还是接口

      3. 该类型的访问修饰符

      等...

    2. 已装载的Class的详细信息：

      1. 运行时常量池：在方法区中，每个类型都对应一个常量池，存放该类型所用到的所有常量，常量池中存储了诸如文字字符串、final变量值、类名和方法名常量。它们以数组形式通过索引被访问，是外部调用与类联系及类型对象化的桥梁。（存的可能是个普通的字符串，然后经过常量池解析，则变成指向某个类的引用）

      2. 字段信息：字段信息存放类中声明的每一个字段的信息，包括字段的名、类型、修饰符。字段名称指的是类或接口的实例变量或类变量，字段的描述符是一个指示字段的类型的字符串，如private A a=null;则a为字段名，A为描述符，private为修饰符

      3. 方法信息：类中声明的每一个方法的信息，包括方法名、返回值类型、参数类型、修饰符、异常、方法的字节码。(在编译的时候，就已经将方法的局部变量、操作数栈大小等确定并存放在字节码中，在装载的时候，随着类一起装入方法区。)

    3. 静态变量(静态区)：(静态static 第9天讲)

      • 类变量，类的所有实例都共享，我们只需知道，在方法区有个静态区，静态区专门存放静态变量和静态块。

  5. 非RAM存储：硬盘等永久存储空间

其中主要是堆，栈的存储。

堆，栈：

  1. 函数中定义的一些基本类型的数据变量和对象的引用变量都在函数的栈内存中分配。栈的优势是存取速度比堆要快，仅次于直接位于CPU 的寄存器，而且数据可以共享（只在当前栈内）。存在栈中的数据大小与生存周期必须是确定的。因此里面的变量通常是局部变量、函数参数等。当在一段代码块定义一个变量时（局部变量），Java就在栈中为这个变量分配内存空间，当该变量所在的作用域结束后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

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

    ​ 注意：在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。​ 引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序 运行到使用 new 产生数组或者对象的语句所在的作用域之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不可能再被使用，但仍 然占据内存空间不放，在随后的一个不确定的时间被(GC)垃圾回收器收走（释放掉）。

  3. 栈：就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函数参数等。

  4. 堆：就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序没有释放掉，那么在程序结束后，操作系统会自动回收。

更深层次的认识java内存分配：

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

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

在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。

引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

栈与堆都是Java用来在RAM【random-access-memory】[随机存取存储器]中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

Java的堆是一个运行时数据区，类的对象从中分配空间。这些对象通过new来建立，它们不需要程序代码来显式的释放。

堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。

但缺点是，由于要在运行时动态分配内存，存取速度较慢。

栈的优势是，存取速度比堆要快，仅次于寄存器，栈中的数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

栈中主要存放一些基本类型的变量（int,short,long,byte,float,double,boolean,char）和对象引用。

进一步观察java内存分配：

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

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,它是由编译器完成的，它有利于节省空间。

而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

String是一个特殊的包装类数据。可以用：

Stringstr=newString("abc"); 或 Stringstr="abc"; 两种的形式来创建，第一种是用new() 来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。而第二种是先在栈中创建一个对 String 类的对象引用变量 str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令 str指向“abc”，如果已经有“abc”则直接令 str 指向“abc”。

比较类里面的数值是否相等时，用equals()方法；

当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。

Stringstr1="abc";

Stringstr2="abc";

System.out.println(str1==str2);//true

可以看出 str1 和 str2是指向同一个对象的。

Stringstr1=newString("abc");

Stringstr2=newString("abc");

System.out.println(str1==str2);//false

用 new 的方式是生成不同的对象。每一次生成一个。

因此用第一种方式创建多个“abc”字符串，在内存中其实只存在一个对象而已。

这种写法有利与节省内存空间，同时它可以在一定程度上提高程序的运行速度，因为 JVM 会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于 Stringstr=newString("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

另一方面,要注意：我们在使用诸如 Stringstr="abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。

担心陷阱！

对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过 new()方法才能保证每次都创建一个新的对象。

由于String类的immutable(不可改变)性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。

如下表达式：

Aa1=newA();

它代表 A 是类，a1是引用，a1不是对象，newA()才是对象，a1引用指向newA() 这个对象。

在JAVA里，“=”不能完全看成是一个赋值语句，它不是在把一个对象赋给另外一个对象，它的执行过程实质上是将右边对象的地址传给了左边的引用，使得左边的引用指向了右边的对象。

JAVA表面上看起来没有指针，但它的引用其实质就是一个指针，引用里面存放的并不是对象，而是该对象的地址，使得该引用指向了对象。

在JAVA里，“=”语句不应该被翻译成赋值语句，因为它所执行的确实不是一个赋值的过程，而是一个传地址的过程，被译成赋值语句会造成很多误解，译得不准确。

再如：Aa2;它代表 A是类，a2是引用，a2不是对象，a2所指向的对象为空 null;

再如：a2=a1;它代表，a2是引用，a1也是引用，a1所指向的对象的地址传给了a2(传址），使得a2和a1指向了同一对象。综上所述，可以简单的记为，在初始化时，“=”语句左边的是引用，右边 new出来的是对象。

在后面的左右都是引用的“=”语句时，左右的引用同时指向了右边引用所指向的对象。

再所谓实例，其实就是对象的同义词。

java中常见的存储机制

  1. 寄存器：

    这是最快的存储区，因为它位于处理器内部，数量极其有限，所以寄存器根据需求进行分配，你不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。

  2. 栈(堆栈)：

    位于通用RAM【random-access-memory】[随机存取存储器]中，但通过堆栈指针可以直接从处理器那里得到支持，堆栈指针若向下移动，则分配新的内存，若向上移动，则释放那些内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时，JAVA系统必须知道存储在堆栈内所有项的确切生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性。

  3. 堆：一种通用的内存池（也位于RAM）中，用于存放所有JAVA对象。堆不同于堆栈的地方是：堆不需要知道存储的数据在堆里存活多长时间。因些，在堆里分配存储空间有很大的灵活性。当需要一个对象时，只需要用NEW写一行简单的代码，当执行这行代码时，会自动在堆里进行存储分配。缺点是用堆进行存储分配和清理要比用堆栈更耗时。

  4. 常量存储区(方法区)：

    常量值一般直接放于程序内部，这样做是安全的，因为它们永远不可能改变。如果是嵌入式，可能常量本身会和程序分开，放在ROM中。

  5. 非RAM存储如果数据完全存活于程序之外，那么它可以不受任何程序的影响。比如流对象和持久化对象。

8.7 对象的实例化内存分析

Person p; 

p = new Person();

【内存分析】

java 中所说的地址值是 java虚拟机计算出来的值，而并非真正的内存地址，这点跟C语句不一样，C语句是可以指向内存地址的。

对象的声明发生在栈空间之中，此时只是声明了一个引用类型的变量 p，（注意类类型的变量都属于引用型变量，类似StringS)，而 p变量此时尚未保存任何数值，或者说 p为空对象即 null，通过 new运算符和类的构造方法为声明的对象分配成员变量。（详情参考如下)：

  1. 成员变量在堆的GC(garbage collection 垃圾回收)区分配空间，执行构造器语句。

  2. new运算符为成员变量分配内存空间后将返回一个引用赋值给变量 p，确保这些成员变量能够通过 p 引用指向的地址可以访问。当然对象的声明和分配成员变量可以一个步骤完成。例如

    Person p = new Person ();

为对象分配成员变量的内存过程：

  1. 在堆的永久区检查类模板信息，如果没有则执行第二步加载类的模板信息，如内存中有类信息则不执行第二步。

  2. 若没有，则加载类模板信息

  3. 在堆的 GC区开辟合适的空间，保存类的成员变量。

  4. 为类对象的属性赋值此时只是赋缺省的初始化值(即赋默认值)

  5. 在栈内存中调用其构造器，并将构造器执行的结果值，赋值给类的成员变量。（类的方法调用发生在栈空间中，如果执行默认的构造器没有任何结果返回，此时类的成员变量依然是第4步的缺省的初始化值）

  6. 在栈空间执行构造器并将执行的结果传递给堆空间的成员变量（将构造器执行的结果传递给堆空间的成员变量赋值操作）【this.name=name;】

  7. 将堆空间的类成员变量的内存首地址传递给栈的引用变量 p，p 指向了类的这个实例化的对象，此时 p 可以称作 Person类的一个对象，并且可以使用 p.属性或者p.方法的形式访问对象的属性和方法。

results matching ""

    No results matching ""