JVM编译时和运行时，内存的分配

最近在看JVM内存分配的知识，现将自己的理解表述一下，要是有什么不对的地方，欢迎大家指正交流。

示例代码：

public class Sample {

int var1 = 1;

static int var2 =2;

public int add(){

     int var3 =var1+ var2;

     return var3;

}

public int delete(){

    int var4=var1-var2;

    return var4;

}

public static void main(String[] args) {

    new Sample().add();

}

}

在编译源代码时，JVM会为方法内的局部变量和类中的类变量在栈中分配内存，并把变量的实体放到常量池中，常量池就是所谓的缓存机制（此处不详细介绍了）。

方法会被编译成字节码。编译完成后类被编译成二进制的class文件，当程序在运行加载此类时，会把class字节码文件加载到方法区，Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还又一个运行时常量池（运行时常量池在方法区里），就是刚才才介绍了常量池，每个类都有自己的常量池。注意此处说的类的字段、方法存放在方法区里并不是说在方法区内为字段分配空间，而是类的信息存储在这里，当调用到该类时，会在堆内给对象分配存储控件，上述代码中var1就是从方法区中读取该值的信息然后在堆内分配空间。当调用方法时就在栈内分配空间，此处的分配空间是从方法区中读取信息，然后放入栈帧内。

public void bijiao(){
Integer i2 = 12;
System.out.println(System.identityHashCode(i2));
}
public void bijiao2(){
Integer i3 = 12;
System.out.println(System.identityHashCode(i3));
}
public static void main(String[] args) {
test t = new test();
t.bijiao();
t.bijiao2();
}

常量池被整个程序共享，当在不同的方法中（或者不同的类中）定义了相同的变量，他们的地址是一样的，在栈内只分配了一个存储空间。

------------------------------------------------------------------------------------------------------------------------

java中内存的分配

          java程序在运行时，内存结构分为：方法区（method），栈内存（stack），堆内存（heap），本地方法栈（java中的jni调用）等。

          jvm为每一个运行的线程分配一个堆栈（方法栈），堆栈以帧为单位来保存线程的运行的状态，java中，我们将当前正在运行的方法称为当前方法，当java激活（执行）一个方法时，就会向堆栈中压入一个帧，堆栈中的这一帧就代表这个方法在运行时jvm为它分配的内存，这一帧叫做当前帧，帧里可以存放方法的参数，中间结果和局部变量等。当当前方法执行完时，当前帧也会出栈，即该内存区域被释放。方法栈中只会存放基本类型数据和对象的引用。

         基础数据类型直接在栈空间分配，方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收。引用数据类型，需要用new来创建，既在栈空间分配一个地址空间，又在堆空间分配对象的类变量 。方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完成后从栈空间回收。局部变量new出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC回收。方法调用时传入的literal参数，先在栈空间分配，在方法调用完成后从栈空间收回。字符串常量在DATA区域分配，this在堆空间分配。数组既在栈空间分配数组名称，又在堆空间分配数组实际的大小！

         

一个类的全局变量，全局常量有存放在哪呢？

这些信息存放在一个叫做方法区的地方，在每一个jvm的内部，都有一个称为方法去的逻辑存储区。

方法区存放装载的类数据信息包括: 
    (1):基本信息: 
           1)每个类的全限定名 
           2)每个类的直接超类的全限定名(可约束类型转换) 
           3)该类是类还是接口 
           4)该类型的访问修饰符 
           5)直接超接口的全限定名的有序列表 
    (2):每个已装载类的详细信息: 
           1)运行时常量池:  
            jvm为每个已加载的类型都维护一个常量池。常量池就是这个类型用到的常量的一个有序集合，包括实际的常量(string, 
            integer, 和floating point常量)和对类型，域和方法的符号引用。池中的数据项象数组项一样，是通过索引访问的。 
            因为常量池存储了一个类型所使用到的所有类型，域和方法的符号引用，所以它在java 程序 的动态链接中起了核心的作用。

           2)字段信息: 
           类中声明的每一个字段的信息(字段名,类型,修饰符)。 
           3)方法信息: 
           类中声明的每一个方法的信息(名,返回类型,参数类型,修饰符,方 法的字节码和异常表)。 
           4)静态变量    也就是类变量(class variables)用关键字 static 修饰,在类加载的时候,分配类变量的内存,以后在生成类的实例对象时,将共享这块内存(类变量)  ,任何一个对象对类变  
           量的修改,都会影响其它对象。外部有两种访问方式:通过对象来访问或通过类名来访问。

           5)到类 classloader 的引用:即到该类的类装载器的引用。 
           6)到类 class 的引用: 
            虚拟机为每一个被装载的类型创建一个 class 实例, 用来代表这个被装载的类。

方法区是被多个线程所共享的，因此会有线程安全的问题。

编译器将源代码编译成字节码(.class)时, 就已经将各种类型的方法的局部变量, 操作数栈大小确定并放在字节码中,随着类一并装载入方法区。当调用方法时,通过访问方法区中的类的信息,得到局部变量以及操作数栈的大小。  
也就是说: 在方法中定义的一些基本类型的变量和对象的引用变量都在方法的栈内存中分配。 当在一段代码块定义一个变量时,Java 就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java 会自动释放掉为该变量所分配的内存空间,

该内存空间可以立即被另作它用。

          问题：方法区的内存在哪分配？

          单独的一块内存，他是和堆内存，栈内存平级的内存区域，在一个jvm中，只有一个方法区，多个线程共享。例如，有个set方法，被线程a和线程b执行，set方法存在哪呢，很显然，存放在方法区。那么为什么还要有方法栈呢，也就是存放帧的内存区域，因为方法在执行时，就会被调入线程所在的方法栈呢内，为变量分配空间，计算逻辑等，需要一个区域来存放方法执行时的中间结果啊，需要到的参数啊等等。

           

          问题：类中的属性成员的信息在哪存储？

          栈内存和堆内存比较 
          栈与堆都是 Java 用来在内存中存放数据的地方。与 C++不同,Java 自动管理栈和堆,程序员不能直接地设置栈或堆。 
          Java 的堆是一个运行时数据区,对象从中分配空间。堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的,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 是一个特殊的包装类数据。可以用: 
          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 
    可以看出 str1 和 str2 是指向同一个对象的。 
           String str1 = new String ("abc"); 
           String str2 = new String ("abc"); 
           System.out.println(str1==str2); // false 
           用 new 的方式是生成不同的对象。每一次生成一个。 
           因此用第一种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已。 这种写法有利于节省内存空间。同时它可以在一定程度上提高程序的运行速度,因为 JVM 会自动根据栈中数据的实际情况来决定是否有必要创建新对象。 
          而对于 String str = new String("abc");的代码,则一概在堆中创建新对象,而不管其字符串值是否相等,是否 有必要创建新对象,从而加重了程序的负担。 
          另一方面, 要注意: 我们在使用诸如 String str = "abc";的格式时,总是想当然 地认为,创建了 String 类的对象 str。担心陷阱!对象可能并没有被创建!而可能只是指向一个先前已经创建的对象。 
         只有通过 new()方法才能保证每次都创建一个新的对象。 由于 String 类的值不可变性(immutable)  ,当 String 变量需要经常变换其值时,应该考虑使用 StringBuffer 或 StringBuilder 类,以提高程序效率。