比如，一个简单的变量初始化，就导致产生两个与操作数栈交互的字节码。

int i;

0:	iconst_0	// Push 0 to top of the operand stack
1:	istore_1	// Pop value from top of operand stack and store as local variable 1

动态链接

该引用指向将要被运行的方法所属的类的常量池。该引用也用于辅助动态链接。

但JVM必须保证：解析发生在每一个引用被首次使用前，同一时候在该时间点，假设遇到分析错误能够抛出异常。绑定是一个处理过程，它将被符号引用标识的字段、方法或类替换为一个直接引用。

这个处理过程仅仅发生一次。由于符号引用须要被全然替换。假设一个符号引用关联着一个类，而该类还没有被解析，那么该类也会被马上载入。

每一个直接引用都被以偏移的方式存储。该存储结构关联着变量或方法的运行时位置。

数组和对象永远不能被分配到栈上。由于frame被设计为在其创建后不可更改大小。Frame仅仅存储用于指向堆中的数组和对象的指针。

不像原始类型以及存储在局部变量数组中的引用（以上这些都指存储在每一个frame里的），对象总是存储在堆上。所以当一个方法运行结束，它们不会被马上移除（对象仅仅能被垃圾回收器回收）。

• 青年代
• 通常又被切割为Eden跟Survivor两个部分
  
• 老年代（也称之为终身代）
• 永久代

内存管理

对象和数组永远都不会被显式释放，因此仅仅能依靠垃圾回收器来自己主动地回收它们。

1. 新对象和数组被创建在年轻代
   
2. 次垃圾回收器将在年轻代上运行。那些仍然存活着的对象。将被从eden区移动到survivor区
   
3. 主垃圾回收器将会把对象在代与代之间进行移动，主垃圾回收器一般会导致应用程序的线程暂停。那些仍然存活着的对象将被从年轻代移动到老年代
   
4. 永久代会在每次老年代被回收的时候同一时候进行，它们在两者中其一满了之后都会被回收
   

非堆式内存

• 永久代中包括：
  
• 方法区
  
• 内部字符串
  
• 代码缓存：用于编译以及存储方法，这些方法已经被JIT编译成本地代码

JIT编译

为了提高性能，OracleHotspot VM会寻找那些有规律地运行的字节码，并把他们编译为本地原生代码。而原生代码将会被存储在代码缓存的非“堆”内存区。这样，HotspotVM会尝试去选择最合适的方式在它编译代码以及它运行被解释过代码的额外时间之间作出权衡。

• 类载入器的引用
  
• 运行时常量池
  
• 数值常量
  
• 字段引用
  
• 方法引用
• 属性
• 字段数据
  
• 对每一个字段
• 名称
• 类型
• 改动器
• 属性
• 方法数据
• 对每一个方法
• 名称
• 返回值
• 參数类型（按顺序）
• 改动器
• 属性
• 方法体
• 对每一个方法
• 字节码
  
• 操作数栈大小
  
• 局部变量大小
  
• 局部变量表
  
• 异常表
  
• 对每一个异常处理器
  
• 起始点
  
• 终止点
  
• 对处理器代码的PC偏移量
  
• 被捕获的异常类在常量池中的索引
  

假设两个线程企图訪问一个还没有被载入的类（该类必须仅仅能被载入一次）的字段或者方法，直到该类被载入完毕，这两个线程才干继续运行。

ClassFile {
    u4			magic;
    u2			minor_version;
    u2			major_version;
    u2			constant_pool_count;
    cp_info		contant_pool[constant_pool_count – 1];
    u2			access_flags;
    u2			this_class;
    u2			super_class;
    u2			interfaces_count;
    u2			interfaces[interfaces_count];
    u2			fields_count;
    field_info		fields[fields_count];
    u2			methods_count;
    method_info		methods[methods_count];
    u2			attributes_count;
    attribute_info	attributes[attributes_count];
}

package org.jvminternals;

public class SimpleClass {

    public void sayHello() {
        System.out.println("Hello");
    }

}

public class org.jvminternals.SimpleClass
  SourceFile: "SimpleClass.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#17         //  java/lang/Object."<init>":()V
   #2 = Fieldref           #18.#19        //  java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #20            //  "Hello"
   #4 = Methodref          #21.#22        //  java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #23            //  org/jvminternals/SimpleClass
   #6 = Class              #24            //  java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lorg/jvminternals/SimpleClass;
  #14 = Utf8               sayHello
  #15 = Utf8               SourceFile
  #16 = Utf8               SimpleClass.java
  #17 = NameAndType        #7:#8          //  "<init>":()V
  #18 = Class              #25            //  java/lang/System
  #19 = NameAndType        #26:#27        //  out:Ljava/io/PrintStream;
  #20 = Utf8               Hello
  #21 = Class              #28            //  java/io/PrintStream
  #22 = NameAndType        #29:#30        //  println:(Ljava/lang/String;)V
  #23 = Utf8               org/jvminternals/SimpleClass
  #24 = Utf8               java/lang/Object
  #25 = Utf8               java/lang/System
  #26 = Utf8               out
  #27 = Utf8               Ljava/io/PrintStream;
  #28 = Utf8               java/io/PrintStream
  #29 = Utf8               println
  #30 = Utf8               (Ljava/lang/String;)V
{
  public org.jvminternals.SimpleClass();
    Signature: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
        0: aload_0
        1: invokespecial #1    // Method java/lang/Object."<init>":()V
        4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
          0      5      0    this   Lorg/jvminternals/SimpleClass;

  public void sayHello();
    Signature: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
        0: getstatic      #2    // Field java/lang/System.out:Ljava/io/PrintStream;
        3: ldc            #3    // String "Hello"
        5: invokevirtual  #4    // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
          0      9      0    this   Lorg/jvminternals/SimpleClass;
}

• 常量池：它提供了跟通用符号表提供的同样的信息
  
• 方法：（每一个都包括四个区域）
  
• 签名和訪问标记
  
• 字节码
  
• line number表 – 它给调试器提供相关信息。哪一行关联到哪条字节码指令。

  比如。在sayHello方法中，Java代码的第6行关联着字节码指令行数为0。第7行Java代码关联着字节码指令行数为8
  

• 局部变量表 – 列出了在frame中提供的全部局部变量，在这个样例中。唯一的局部变量是:this
  

第一个操作数getstatic，用来入栈一个指向System类的静态字段out的引用到操作数栈。

接下来的操作数ldc。入栈一个字符串字面量“Hello”到操作数栈。最后。invokevirtual操作数，运行System.out的println方法，这将使得“Hello”作为一个參数从操作数栈出栈，并为当前线程创建一个新的frame。

main方法的运行，将顺序经历载入。链接，以及对额外必要的类跟接口的初始化。