JVM内存结构图解

public class HelloWorld {
　　public static final int a = 10;		//声明全局变量a并赋值
　　
　　public static void main(String[] args){
　　　　HelloWorld hw = new HelloWorld();	//实例化对象hw
　　　　int b = 15;							//声明局部变量b并赋值
　　　　int c = hw.add(b);					//调用add方法并赋值给c
　　}

　　public int add(int b){
　　　　b = change(b);						//调用change方法并赋值给b
　　　　return a + b + 3;					//返回计算结果
　　}

　　public int change(int b){
　　　　return b + 5;						//返回计算结果
　　}
}

/**
 * JVM启动时会将类信息保存到永久代（方法区）
 */
public class HelloWorld

　　minor version: 0　　　　 　　　 //编译副版本号
　　major version: 52　　　　　　　 //编译主版本号，JVM校验class文件时使用，低版本JVM不能运行高版本编译器编译的class文件
　　flags: ACC_PUBLIC, ACC_SUPER　　//ACC_PUBLIC表示可以被包外class访问，ACC_SUPER表示需特殊处理的父类方法

/**
 * 常量池：类似于《编译原理》中介绍的符号表；如希望进一步了解，请阅读附录书单的⑴⑵⑶
 */
　　Constant pool:
　　#1 = Methodref　　　　#6.#22　　　　　　　　 // java/lang/Object."<init>":()V
　　#2 = Class　　　　　　#23　　　　　　　　　　// HelloWorld
　　#3 = Methodref　　　　#2.#22　　　　　　　　 // HelloWorld."<init>":()V
　　#4 = Methodref　　　　#2.#24　　　　　　　　 // HelloWorld.add:(I)I
　　#5 = Methodref　　　　#2.#25　　　　　　　　 // HelloWorld.change:(I)I
　　#6 = Class　　　　　　#26　　　　　　　　　　// java/lang/Object
　　#7 = Utf8　　　　　　 a
　　#8 = Utf8　　　　　　 I
　　#9 = Utf8　　　　　　 ConstantValue
　　#10 = Integer　　　　 10
　　#11 = Utf8　　　　　　<init>
　　#12 = Utf8　　　　　　()V
　　#13 = Utf8　　　　　　Code
　　#14 = Utf8　　　　　　LineNumberTable
　　#15 = Utf8　　　　　　main
　　#16 = Utf8　　　　　　([Ljava/lang/String;)V
　　#17 = Utf8　　　　　　add
　　#18 = Utf8　　　　　　(I)I
　　#19 = Utf8　　　　　　change
　　#20 = Utf8　　　　　　SourceFile
　　#21 = Utf8　　　　　　HelloWorld.java
　　#22 = NameAndType　　 #11:#12　　　　　　　　// "<init>":()V
　　#23 = Utf8　　　　　　HelloWorld
　　#24 = NameAndType　　 #17:#18　　　　　　　　// add:(I)I
　　#25 = NameAndType　　 #19:#18　　　　　　　　// change:(I)I
　　#26 = Utf8　　　　　　java/lang/Object


{
/** 静态final变量 a */
　　public static final int a;
　　　　descriptor: I　　　　//字段类型描述符，表明是一个int整形数
　　　　flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL　　　　//字段属性描述符
　　　　ConstantValue: int 10　　　　//常量值


/** 构造方法 */
　　public HelloWorld();
　　　　descriptor: ()V　　　　//方法描述符，V表明返回值为空
　　　　flags: ACC_PUBLIC　　　//方法属性标签
　　　　Code:
　　　　　　stack=1, locals=1, args_size=1　　　// 操作数栈深=1,本地变量数量=1,参数数量=1，0索引总是保存当前方法所属的对象引用(ObjectReference)，所以无参构造方法却显示有1个参数
　　　　　　　　 0: aload_0　　　　　　　　　　 // 从局部变量表索引为0的地方获取对象引用类型，并压入到操作数栈，新建但未初始化
　　　　　　　　 1: invokespecial #1　　　　　　// Method java/lang/Object."<init>":()V 调用父类的初始化方法
　　　　　　　　 4: return　　　　　　　　　　　// 方法返回，返回值为空，栈帧销毁
　　　　　　LineNumberTable:　　　　　　　　　　// LineNumberTable是一个数组，记录源代码所在的行。
　　　　　　　　line 1: 0　　　　　　　　　　 　// line_number(源文件行号) :  start_pc(code[]数组索引)


/** main方法 */
　　public static void main(java.lang.String[]);
　　　　descriptor: ([Ljava/lang/String;)V
　　　　flags: ACC_PUBLIC, ACC_STATIC
　　　　Code:
　　　　　　stack=2, locals=4, args_size=1　　　// 操作数栈深=2,本地变量数量=4,参数数量=1
　　　　　　　　 0: new　#2　　　　　　 // class HelloWorld  创建HelloWorld对象，堆中分配内存，引用值压入栈顶
　　　　　　　　 3: dup　　　　　　　　 // 复制栈顶保存的对象引用，并将HelloWorld引用值再次压入栈顶
　　　　　　　　 4: invokespecial　#3　 // Method "<init>":()V 弹出栈顶的一个元素HelloWorld引用，调用HelloWorld对象的初始化方法
　　　　　　　　 7: astore_1　　　　　　// 弹出栈顶的一个元素HelloWorld引用，将栈顶的HelloWorld引用存入局部变量表的索引1位置
　　　　　　　　 8: bipush　15　　　　　// 将byte类型常数15压入栈顶
　　　　　　　　10: istore_2　　　　　　// 弹出栈顶的一个元素15，并将其存入局部变量表索引2位置
　　　　　　　　11: aload_1　　　　　　 // 将局部变量表的索引1位置的HelloWorld引用压入栈顶
　　　　　　　　12: iload_2　　　　　　 // 将局部变量表的索引2位置的int类型的15压入栈顶
　　　　　　　　13: invokevirtual　#4　 // Method add:(I)I　弹出栈顶的两个元素并调用add方法，返回值33压入栈顶
　　　　　　　　16: istore_3　　　　　　// 弹出栈顶的一个元素33，并将其存入局部变量表索引3位置
　　　　　　　　17: return　　　　　　　// 方法返回，返回值为空，栈帧销毁，线程结束
　　　　　　LineNumberTable:
　　　　　　　　line 5: 0
　　　　　　　　line 6: 8
　　　　　　　　line 7: 11
　　　　　　　　line 8: 17


/** add方法 */
　　public int add(int);
　　　　descriptor: (I)I
　　　　flags: ACC_PUBLIC
　　　　Code:
　　　　　　stack=2, locals=2, args_size=2　　　// 操作数栈深=2,本地变量数量=2,参数数量=2(非静态方法的参数0位置总是为当前方法所属对象的引用，所以只传入了参数b，却显示有2个参数)
　　　　　　　　 0: aload_0　　　　　　 // 将局部变量表的索引0位置的HelloWorld引用压入栈顶
　　　　　　　　 1: iload_1　　　　　　 // 将局部变量表的索引1位置(参数b)的15压入栈顶
　　　　　　　　 2: invokevirtual　#5　 // Method change:(I)I　弹出栈顶的两个元素并调用change方法，返回值20压入栈顶
　　　　　　　　 5: istore_1　　　　　　// 弹出栈顶元素20，并将其存入局部变量表的索引1位置
　　　　　　　　 6: bipush　10　　　　　// 将byte类型常数10压入栈顶
　　　　　　　　 8: iload_1　　　　　　 // 将局部变量表的索引1位置的20压入栈顶
　　　　　　　　 9: iadd　　　　　　　　// 弹出栈顶的两个元素并相加：20 + 10，将结果30存入栈顶
　　　　　　　　10: iconst_3　　　　　　// 将int类型常数3压入栈顶
　　　　　　　　11: iadd　　　　　　　　// 弹出栈顶的两个元素并相加：30 + 3，将结果33存入栈顶
　　　　　　　　12: ireturn　　　　　　 // 返回int类型的数值 33，栈帧销毁
　　　　　　LineNumberTable:
　　　　　　　　line 11: 0
　　　　　　　　line 12: 6


/** change方法 */
　　public int change(int);
　　　　descriptor: (I)I
　　　　flags: ACC_PUBLIC
　　　　Code:
　　　　　　stack=2, locals=2, args_size=2
　　　　　　　　 0: iload_1　　　　　　 // 将局部变量表的索引1位置的15压入栈顶
　　　　　　　　 1: iconst_5　　　　　　// 将int类型常数5压入栈顶
　　　　　　　　 2: iadd　　　　　　　　// 将栈顶的两个元素弹出并相加：5 + 15，并将结果存入栈顶
　　　　　　　　 3: ireturn　　　　　　 // 返回int类型的数值 20，栈帧销毁
　　　　　　LineNumberTable:
　　　　　　　　line 16: 0
}

　　byte[] array = new byte[4];
　　array[0] = 0;
　　array[1] = 1;
　　array[2] = 2;
　　array[3] = 3;</span>

　　0xa726a086: jne　　0xa726a07d　　　　 ;*newarray检测zf标志位：1顺序执行下一条指令；0跳转到0xa726a07d处指令

　　;eax寄存器中保存的是数组的起始内存地址。0xc(%eax)：基址eax + 偏移12。
　　;32位JVM中，数组对象使用12个字节记录两项信息：数组长度4字节 + 数组对象头8字节 = 12字节（0x0 至 0xb），所以保存数据的起始地址是0xc。

　　0xa726a088: movb　　$0x0,0xc(%eax)　　;*bastore将0写入0xc偏移位置
　　0xa726a08c: movb　　$0x1,0xd(%eax)　　;*bastore将1写入0xd偏移位置
　　0xa726a090: movb　　$0x2,0xe(%eax)　　;*bastore将2写入0xd偏移位置
　　0xa726a094: movb　　$0x3,0xf(%eax)　　;*bastore将3写入0xd偏移位置

public static void getAndSet(){
　　Object obj = get();
　　set(obj);
　　getAndSet();
}

public static void getAndSet(){
　　Object obj = get();
　　if(null != obj){
　　　　set(obj);
　　　　getAndSet();
　　}
}

public static void getAndSet(){
　　for( ; ; ){
　　　　Object obj = get();
　　　　set(obj);
　　}
}

/**计算斐波那契数列
 * 0,1,1,2,3,5,8,13
 * 为了计算第7个数，必须先计算第6个；为了计算第6个，先得计算第5个……因为每一步计算的结果都没有存储，所以相同的计算结果反复计算。
 * 每一次方法调用都是两个f(n)的计算，所以第3个数开始，每次的计算都是前面两个数的计算次数之和。这是一个非常非常非常缓慢的算法！！！
 * 相当于每增加1，计算次数就要乘以1.618。
 * 当计算第30个数字的值时，方法调用达到1664079次，栈帧数量等同。
 */
public static int f(int n){
　　if(n == 0){
　　　　return 0;
　　}
　　if(n <= 2){
　　　　return 1;
　　}
　　return f(n-1) + f(n-2);
}

public static int f(int n){
　　int lastlast = 0;
　　int last = 1;
　　int sum = 1;
　　for(int i=2; i<=n; i++){
　　　　sum = last + lastlast;
　　　　lastlast = last;
　　　　last = sum;
　　}
　　return sum;
}

public static void getAndSet(){
　　Object obj = get();
　　if(null != obj){
　　　　set(obj);
　　　　getAndSet();
　　}
}

public static void set(Object obj){
　　obj.value = 10;
　　obj = obj.next;
　　if(null != obj){
　　　　set(obj);
　　}
}

public static void getAndSet(){
　　Object obj = get();
　　while(null != obj){
　　　　set(obj);
　　　　obj = get();
　　}
}

public static void set(Object obj){
　　while(null != obj){
　　　　obj.value = 10;
　　　　obj = obj.next;
　　}
}

public static void build(){
	int[] array = new int[1024 * 1024 * 1024];
	build();
}