java 程式運行的基礎知識

JVM 執行緒棧 到 函數運行

每一個JVM執行緒來說啟動的時候都會建立一個私有的執行緒棧。一個jvm執行緒棧用來儲存棧幀，jvm執行緒棧和C語言中的棧很類似，它負責管理局部變數、部分運算結果，同時也參與函數呼叫和函數傳回的工作。 JVM規範中運行執行緒棧的大小可以是固定的或是動態分配的，也可以是根據一定規則計算的。不同jvm對堆疊的實作會不同，有些可能提供給開發人員自己控制jvm執行緒堆疊初始大小的方式；對於動態分配來說也可能提供對jvm最大和最小值的設定。

當計算一個執行緒所需的分配的大小超出了固定值、或設定的最大值，jvm會拋出StackOverflowError。而對於動態分配棧來說，如果記憶體無法提供足夠的空間來滿足最小值、或需要的值JVM會拋出OutOfMemoryError

棧幀，可以理解成一個函數執行的環境，它管理參數、局部變量、回傳值等等。

每個堆疊幀都包含一個管理局部變數的陣列（ local variables），這個陣列的單元數量在編譯成字節碼的時候就能確定了。對於32-bit 一個單位能夠存放 boolean, byte, char, short, int, float, reference,returnAddress；連續兩個單位就能夠用來存放long 、double。局部變數數組的下標是從0開始，一般而言0位置儲存的是this，後面接著是函數的參數，再是函數中出現的局部變數。

每個堆疊幀也都包含一個(LIFO)操作棧的資料結構（operand stack），它的大小同樣也可以在編譯的時候確定，創建的時候會是個空棧。舉個簡單的例子，來描述它公用，對於int a+b來說，先把push a 進入棧中，再樸實b 進入入棧中，然後同時pop 兩個值執行iadd 指令，再將其加後的結果push入棧中完成指令。

除開以上兩個關鍵的結構，每個堆疊幀還有常數池（ run-time constant pool）、異常拋出管理等結構。在此就不一一詳細說來了，可以參考其他資料。

再來透過一個簡單的 Demo 來說明，一個堆疊幀的工作。首先，我們來看這樣的一個函數：

public int comp(float number1, float number2){
        int result ;
        if(number1 < number2)
            result = 1;
        else
            result = 2;
        return result;
    }

其中函數內邏輯對應的字節碼，如下：

 0: fload_1

 1: fload_2

 2: fcmpg

🠎 : iconst_1

收到字節碼指令稍微說明下：

fload_x：取局部變數數組中第x個，類型fload,push 入棧；

fcmpg：比較兩個單精度浮點數。若兩數大於結果為1，相等則結果為0，小於的話結果為-1;

ifge：跳轉指令；

iconst_x:push 常數x入棧；

istore_x:pop棧存入局部變數陣列第x個；

iload_x:讀取局部變數數組第x個，入棧；

ireturn:函數結束返回int型；

細心點觀察可以發現i開頭指代int，f開頭指涉fload，load代表載入，if代表跳轉等等，其中字節碼的操作碼定義也是有一定意義的，詳情可以翻譯jvm字節碼相關標準。再來看看，jvm如何在堆疊幀結構上執行情況，以具體調用comp(1.02,2.02)為例：

Java 的 Class

說字節碼，一定少不了.class。不妨，以一個demo類別 來具體看class 的內容，類別非常簡單，兩個函數一個say,另外一個就是上面的cmp函數。

public class Hello {

    public void say(){
        System.out.println("Hello world!");
    }

    public int comp(float number1, float number2){
        int result ;
        if(number1 < number2)
            result = 1;
        else
            result = 2;
        return result;
    }
}

用 javac -g:none Hello.java 來編譯這個類別的，然後用 javap -c -v Hello.class 來解析編譯的class。

Classfile /src/main/java/com/demo/Hello.class
  Last modified 2016-10-28; size 404 bytes
  MD5 checksum 9ac6c800c312d65b568dd2a0718bd2c5public class com.demo.Hello
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:   #1 = Methodref          #6.#14         // java/lang/Object."<init>":()V
   #2 = Fieldref           #15.#16        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #17            // Hello world!
   #4 = Methodref          #18.#19        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #20            // com/demo/Hello
   #6 = Class              #21            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               say
  #11 = Utf8               comp
  #12 = Utf8               (FF)I
  #13 = Utf8               StackMapTable
  #14 = NameAndType        #7:#8          // "<init>":()V
  #15 = Class              #22            // java/lang/System
  #16 = NameAndType        #23:#24        // out:Ljava/io/PrintStream;
  #17 = Utf8               Hello world!
  #18 = Class              #25            // java/io/PrintStream
  #19 = NameAndType        #26:#27        // println:(Ljava/lang/String;)V
  #20 = Utf8               com/demo/Hello
  #21 = Utf8               java/lang/Object
  #22 = Utf8               java/lang/System
  #23 = Utf8               out
  #24 = Utf8               Ljava/io/PrintStream;
  #25 = Utf8               java/io/PrintStream
  #26 = Utf8               println
  #27 = Utf8               (Ljava/lang/String;)V{  public com.demo.Hello();
    descriptor: ()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

  public void say();
    descriptor: ()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 world!
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return

  public int comp(float, float);
    descriptor: (FF)I
    flags: ACC_PUBLIC
    Code:      stack=2, locals=4, args_size=3
         0: fload_1         1: fload_2         2: fcmpg         3: ifge          11
         6: iconst_1         7: istore_3         8: goto          13
        11: iconst_2        12: istore_3        13: iload_3        14: ireturn
      StackMapTable: number_of_entries = 2
        frame_type = 11 /* same */
        frame_type = 252 /* append */
          offset_delta = 1
          locals = [ int ]
}

解釋下其中涉及的新的操作碼

getstatic：获取镜头变量;
invokevirtual：调用函数；
return：void 函数结束返回；

在 public int comp(float, float) code 這段程式碼裡面就能看到上面提到的字節碼運行的例子。有了個感性認識，其實大體看到class檔案裡面，除了字節碼指令外，還包括了常數pool，存取標誌（public 等），類別的相關資訊（屬性、函數、常數等）。因為前面用的是 -g:node進行編譯的，其他模式下還可以有其他擴充、偵錯資訊也包括在class裡面。官方給的class檔案格式，詳細如下：

ClassFile {
    u4             magic;
    u2             minor_version;
    u2             major_version;
    u2             constant_pool_count;
    cp_info        constant_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];
}

magic: 就是非常有名的 0xCAFEBABE ,一個識別class檔案；

minor_version 、major_version ：指的是java class 文件的版本，一般说class文件的版本是 XX.xx 其中XX 就是major，xx是minor，比如上面demo中的版本是52.0 代表就是 minor 0，major 51.

constant_pool_count:就是常量池元素个数，cp_info constant_pool[constant_pool_count-1] 就是相关的详细信息了。

access_flags：指的是访问标识例如ACC_PUBLIC、ACC_FINAL、ACC_INTERFACE、ACC_SUPER 写过java的相信看名字应该知道啥意思，ACC是access的缩写。

其他具体的，就不一一介绍了详细可以直接参考官方文档。

动态生成java字节码

当然，你可以直接按照官方的class文件格式来直接写 byte[]，然后自定义个 class load 载入编写的byte[]来实现动态生成class。不过，这个要求可能也有点高，必须的非常熟悉class文件格式才能做到。这里demo还是借助 ASM 这个类库来简单演示下，就编写下 上面的Hello 不过里面只实现say的方法。如下：

public class AsmDemo {    public static final String CLASS_NAME = "Hello";    
    public static final AsmDemoLoad load = new AsmDemoLoad();    private static class AsmDemoLoad extends ClassLoader {        public AsmDemoLoad() {            super(AsmDemo.class.getClassLoader());
        }        public Class<?> defineClassForName(String name, byte[] data) {            return this.defineClass(name, data, 0, data.length);
        }
    }    public static byte[] generateSayHello() throws IOException {

        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        classWriter.visit(V1_7, ACC_PUBLIC + ACC_SUPER, CLASS_NAME, null, getInternalName(Object.class), null);    
        //默认初始化函数
        Method constructorMethod = Method.getMethod("void <init> ()");
        GeneratorAdapter constructor = new GeneratorAdapter(ACC_PUBLIC, constructorMethod, null, null, classWriter);
        constructor.loadThis();        //每个类都要基础Object
        constructor.invokeConstructor(Type.getType(Object.class), constructorMethod);
        constructor.returnValue();
        constructor.endMethod();

        Method mainMethod = Method.getMethod("void say ()");
        GeneratorAdapter main = new GeneratorAdapter(ACC_PUBLIC, mainMethod, null, null, classWriter);
        main.getStatic(Type.getType(System.class), "out", Type.getType(PrintStream.class));
        main.push("Hello world!");
        main.invokeVirtual(Type.getType(PrintStream.class), Method.getMethod("void println (String)"));
        main.returnValue();
        main.endMethod();        return classWriter.toByteArray();
    }    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException,
            InvocationTargetException, InstantiationException, NoSuchMethodException, SecurityException, IOException {        byte[] code = AsmDemo.generateSayHello();        //反射构建 hello 类，调用hello方法。
        Class<?> hello = load.defineClassForName(CLASS_NAME, code);
        hello.getMethod("say", null).invoke(hello.newInstance(), null);
    }
}

关于动态生成字节码用途，一定场景下是可以提升效率与性能，因为动态生成的类和普通的载入类并无太大区别。手工优化后的字节码执行可能比编译的要优，可以替代反射使用的许多场景 同时避免反射的性能消耗。很著名的一个例子，fastJSON 就是使用内嵌 ASM 框架动态生成字节码类，来进行序列和反序列化工作，是目前公认最快的json字符串解析。