JAVA关于变量的存储位置举例验证

        初步学习JVM，对JVM的内存管理了解了一点点皮毛之后，发现对变量的存储位置有了点迷茫，通过网上搜索，及自己写点代码验证，有了一点认识，现在整理一下。

        变量分类：

       calss variable：类变量，也称静态变量，声明在类内部，方法之外，且有static修饰

       instance variable：实例变量，生命在类内部，方法之外，未有static修饰

       local variable：局部变量，声明在方法内部，包括形式参数(就是声明在方法括号中的参数)

      

       类变量保存在方法区(method area)中,实例变量保存在堆(heap)中,局部变量保存在JAVA栈(stack)中。

     如果一个变量所指向的对象(字面值)在编译期就已确定，则该对象会存入常量池中，变量指向常量池。

 

下面举些例子。下面的代码，为了看上去更直观，有些地方，不太符合JAVA规范。

例1 public class A1 { public String a1="abc"; public Integer Int1=100; } /** * 验证编译期就确定字面值的对象保存到常量池中 *不同类的变量比较，同类不同类型的变量比较 */ public class A2 { public String a2="abc"; public Integer Int2=100; public static void compare(){ String s="abc"; Integer i=100; System.out.println(new A1().a1==new A2().a2); System.out.println(new A1().a1==s); System.out.println(new A2().a2==s); System.out.println(new A1().Int1==new A2().Int2); System.out.println(new A1().Int1==i); System.out.println(new A2().Int2==i); } public static void main(String[] args){ compare(); } 运行结果： true true true true true true 全是true，说明不管变量被存储在哪里，只有在编译期就能确定它所指向的对象位置（常量池），那么这些变量用==比较都是true。

例2 /** * 验证类变量存在在方法区中 * 在堆中new多个对象后，这些对象共同使用存于方法区中的类变量 * */ public class Test { private static String s; private static int i; public Test(String s ,int i){ this.s=new String(s); this.i=i; } public static void main(String[] args){ Test t1=new Test("t11",1); Test t2=new Test("t22",2); System.out.println("t1==t2 is "+(t1==t2)); System.out.println("t1.s="+t1.s+" t2.s="+t2.s); System.out.println("t1.s==t2.s is "+(t1.s==t2.s)); System.out.println("t1.i="+t1.i+" t2.i="+t2.i); System.out.println("t1.i==t2.i "+(t1.i==t2.i)); } } 运行结果 t1==t2 is false t1.s=t22  t2.s=t22 t1.s==t2.s is true t1.i=2  t2.i=2 t1.i==t2.i true 说明：t1==t2 is false 表明t1,t2指向堆中不同的2个对象。t1.s=t22 ,t2.s=t22 ,t1.s==t2.s is true,均说明了t2对s操作时，影响了t1.s，但是t1.s和t2.s在编译期时是未确定其引用值的，而且t1.s和 t2.s赋值时都用了new，说明t1.s和t2.s所指向的对象在堆中。那么t2.s能影响到t1.s，并且t1.s==t2.s，就只有一个可能，那就是类变量s保存在方法区中，t1.s和t2.s其实都是同一个变量。在堆中new多个对象后，这些对象共同使用存于方法区中的类变量

例3 /** * 验证实例变量不存在方法区中 * 在堆中new多个对象后，这些对象使用各自的实例变量 * */ public class Test { private String s; private int i; public Test(String s ,int i){ this.s=new String(s); this.i=i; } public static void main(String[] args){ Test t1=new Test("t11",1); Test t2=new Test("t22",2); System.out.println("t1==t2 is "+(t1==t2)); System.out.println("t1.s="+t1.s+" t2.s="+t2.s); System.out.println("t1.s==t2.s is "+(t1.s==t2.s)); System.out.println("t1.i="+t1.i+" t2.i="+t2.i); System.out.println("t1.i==t2.i "+(t1.i==t2.i)); } } 运行结果 t1==t2 is false t1.s=t11  t2.s=t22 t1.s==t2.s is false t1.i=1  t2.i=2 t1.i==t2.i false 说明：该代码只是将例2的代码中的类变量变成实例变量。通过看运行结果，发现t2无法影响t1的变量了，说明t1.s和t2.s不再是同一个变量了，那么实例变量s就肯定不是存在方法区中了。那么实例变量是存在堆中还是栈中呢？下面进行验证。

例4 /** * 验证实例变量位于堆中被共享 * */ public class Test01 extends Thread { private int a=0; public void run(){ for(int i=0;i<10;i++) a++; System.out.println(Thread.currentThread().getName()+"---a="+a); } public static void main(String[] args){ Test01 t1=new Test01(); Thread td1=new Thread(t1); Thread td2=new Thread(t1); td1.start(); td2.start(); } } 运行结果 Thread-2---a=10 Thread-1---a=20 说明：通过了解JVM数据运行区域知道，方法区和堆是线程共享的，JAVA栈是线程私有的。假设实例变量存储于栈中，那么上面的运行结果应该a都是等于10，但是并不是我们猜测的结果，说明实例变量a被共享了。通过例3我们知道实例变量不在方法区，它又被共享，那就只能在堆中。

例5 /** * 验证局部变量位于栈中 * */ public class Test01 extends Thread { public void run(){ int a=0; for(int i=0;i<10;i++) a++; System.out.println(Thread.currentThread().getName()+"---a="+a); } public static void main(String[] args){ Test01 t1=new Test01(); Thread td1=new Thread(t1); Thread td2=new Thread(t1); td1.start(); td2.start(); } } 运行结果 Thread-2---a=10 Thread-1---a=10 说明：int a=0声明在方法内部，说明它是局部变量。运行结果两个线程中的a都等于10，说明它们所拥有的a，互不干扰，是私有的，则说明局部变量存储在栈中。

关于变量优化

以下内容来源：http://www.examw.com/java/jichu/154546/index.html

如果您频繁存取变量，就需要考虑从何处存取这些变量。变量是 static 变量，还是堆栈变量，或者是类的实例变量？变量的存储位置对存取它的代码的性能有明显的影响？例如，请考虑下面这段代码： class StackVars { private int instVar; private static int staticVar; // 存取堆栈变量 void stackAccess(int val) { int j = 0; for (int i = 0; i < val; i++) j += 1; } // 存取类的实例变量 void instanceAccess(int val) { for (int i = 0; i < val; i++) instVar += 1; } // 存取类的 static 变量 void staticAccess(int val) { for (int i = 0; i < val; i++) staticVar += 1; } } 这段代码中的每个方法都执行相同的循环，并反复相同的次数。唯一的不同是每个循环使一个不同类型的变量递增。方法 stackAccess 使一个局部堆栈变量递增，instanceAccess 使类的一个实例变量递增，而 staticAccess 使类的一个 static 变量递增。 　　instanceAccess 和 staticAccess 的执行时间基本相同。但是，stackAccess 要快两到三倍。存取堆栈变量如此快是因为，JVM 存取堆栈变量比它存取 static 变量或类的实例变量执行的操作少。请看一下为这三个方法生成的字节码： Method void stackAccess(int) 　　0 iconst_0 //将 0 压入堆栈。 　　1 istore_2 //弹出 0 并将它存储在局部分变量表中索引为 2 的位置 (j)。 　　2 iconst_0 //压入 0。 　　3 istore_3 //弹出 0 并将它存储在局部变量表中索引为 3 的位置 (i)。 　　4 goto 13 //跳至位置 13。 　　7 iinc 2 1 //将存储在索引 2 处的 j 加 1。 　　10 iinc 3 1 //将存储在索引 3 处的 i 加 1。 　　13 iload_3 //压入索引 3 处的值 (i)。 　　14 iload_1 //压入索引 1 处的值 (val)。 　　15 if_icmplt 7 //弹出 i 和 val。如果 i 小于 val，则跳至位置 7。 　　18 return //返回调用方法。 　　Method void instanceAccess(int) 　　0 iconst_0 //将 0 压入堆栈。 　　1 istore_2 //弹出 0 并将它存储在局部变量表中索引为 2 的位置 (i)。 　　2 goto 18 //跳至位置 18。 　　5 aload_0 //压入索引 0 (this)。 　　6 dup //复制堆栈顶的值并将它压入。 　　7 getfield #19 <Field int instVar> 　　//弹出 this 对象引用并压入 instVar 的值。 　　10 iconst_1 //压入 1。 　　11 iadd //弹出栈顶的两个值，并压入它们的和。 　　12 putfield #19 <Field int instVar> 　　//弹出栈顶的两个值并将和存储在 instVar 中。 　　15 iinc 2 1 //将存储在索引 2 处的 i 加 1。 　　18 iload_2 //压入索引 2 处的值 (i)。 　　19 iload_1 //压入索引 1 处的值 (val)。 　　20 if_icmplt 5 //弹出 i 和 val。如果 i 小于 val，则跳至位置 5。 　　23 return //返回调用方法。 　　Method void staticAccess(int) 　　0 iconst_0 //将 0 压入堆栈。 　　1 istore_2 //弹出 0 并将它存储在局部变量表中索引为 2 的位置 (i)。 　　2 goto 16 //跳至位置 16。 　　5 getstatic #25 <Field int staticVar> 　　//将常数存储池中 staticVar 的值压入堆栈。 　　8 iconst_1 //压入 1。 　　9 iadd //弹出栈顶的两个值，并压入它们的和。 10 putstatic #25 <Field int staticVar> 　　//弹出和的值并将它存储在 staticVar 中。 　　13 iinc 2 1 //将存储在索引 2 处的 i 加 1。 　　16 iload_2 //压入索引 2 处的值 (i)。 　　17 iload_1 //压入索引 1 处的值 (val)。 　　18 if_icmplt 5 //弹出 i 和 val。如果 i 小于 val，则跳至位置 5。 　　21 return //返回调用方法。 查看字节码揭示了堆栈变量效率更高的原因。JVM 是一种基于堆栈的虚拟机，因此优化了对堆栈数据的存取和处理。所有局部变量都存储在一个局部变量表中，在 Java 操作数堆栈中进行处理，并可被高效地存取。存取 static 变量和实例变量成本更高，因为 JVM 必须使用代价更高的操作码，并从常数存储池中存取它们。（常数存储池保存一个类型所使用的所有类型、字段和方法的符号引用。） 　　通常，在第一次从常数存储池中访问 static 变量或实例变量以后，JVM 将动态更改字节码以使用效率更高的操作码。尽管有这种优化，堆栈变量的存取仍然更快。 　　考虑到这些事实，就可以重新构建前面的代码，以便通过存取堆栈变量而不是实例变量或static 变量使操作更高效。请考虑修改后的代码： class StackVars { private int instVar; private static int staticVar; void instanceAccess(int val) { int j = instVar; for (int i = 0; i < val; i++) j += 1; instVar = j; } void staticAccess(int val) { int j = staticVar; for (int i = 0; i < val; i++) j += 1; staticVar = j; } } 方法 instanceAccess 和 staticAccess 被修改为将它们的实例变量或 static 变量复制到局部堆栈变量中。当变量的处理完成以后，其值又被复制回实例变量或 static 变量中。这种简单的更改明显提高了 instanceAccess 和 staticAccess 的性能。这三个方法的执行时间现在基本相同，instanceAccess 和 staticAccess 的执行速度只比 stackAccess 的执行速度慢大约 4%。 　　这并不表示您应该避免使用 static 变量或实例变量。您应该使用对您的设计有意义的存储机制。例如，如果您在一个循环中存取 static 变量或实例变量，则您可以临时将它们存储在一个局部堆栈变量中，这样就可以明显地提高代码的性能。这将提供最高效的字节码指令序列供 JVM 执行。