Grundkenntnisse in der Ausführung von Java-Programmen

JVM-Thread-Stack zur Funktionsausführung

Jeder JVM-Thread erstellt beim Start einen privaten Thread-Stack. Ein JVM-Thread-Stapel wird zum Speichern von Stapelrahmen verwendet. Der JVM-Thread-Stapel ist dem Stapel in der C-Sprache sehr ähnlich. Er ist für die Verwaltung lokaler Variablen und einiger Operationsergebnisse verantwortlich und ist auch an Funktionsaufrufen und Funktionsrückgaben beteiligt. Die Größe des laufenden Thread-Stapels in der JVM-Spezifikation kann fest oder dynamisch zugewiesen werden oder nach bestimmten Regeln berechnet werden. Die Implementierung des Stapels durch verschiedene JVMs ist unterschiedlich. Einige bieten Entwicklern möglicherweise Möglichkeiten zur Steuerung der anfänglichen Größe des JVM-Thread-Stacks für die dynamische Zuordnung. Sie stellen möglicherweise auch Einstellungen für die Maximal- und Minimalwerte des JVM bereit.

Wenn die Berechnung der für einen Thread erforderlichen Zuordnungsgröße den festen Wert oder den festgelegten Maximalwert überschreitet, löst JVM einen StackOverflowError aus. Wenn der Speicher bei dynamisch zugewiesenen Stapeln nicht genügend Speicherplatz bereitstellen kann, um den Mindestwert oder den erforderlichen Wert zu erfüllen, löst die JVM einen OutOfMemoryError

-Stapelrahmen aus, der als Funktionsausführungsumgebung verstanden werden kann, die Parameter verwaltet , lokale Variablen, Rückgabewerte usw.

Jeder Stapelrahmen enthält ein Array, das lokale Variablen verwaltet (lokale Variablen). Die Anzahl der Einheiten in diesem Array kann beim Kompilieren in Bytecode bestimmt werden. Für 32-Bit kann eine Einheit boolean, byte, char, short, int, float, reference, returnAddress speichern; zwei aufeinanderfolgende Einheiten können zum Speichern von long und double verwendet werden. Der Index des lokalen Variablenarrays beginnt bei 0. Im Allgemeinen wird dies an der 0-Position gespeichert, gefolgt von den Parametern der Funktion und dann den lokalen Variablen, die in der Funktion erscheinen.

Jeder Stapelrahmen enthält auch eine (LIFO-)Operationsstapeldatenstruktur (Operandenstapel). Die Größe kann auch während der Kompilierung bestimmt werden. Bei der Erstellung handelt es sich um einen leeren Stapel. Nehmen wir ein einfaches Beispiel, um die allgemeine Verwendung von int a b zu beschreiben: Schieben Sie zuerst a in den Stapel, dann b in den Stapel, fügen Sie dann die beiden Werte gleichzeitig ein und führen Sie die iadd-Anweisung aus Fügen Sie das Ergebnis hinzu. Schieben Sie es auf den Stapel, um die Anweisung abzuschließen.

Zusätzlich zu den beiden oben genannten Schlüsselstrukturen verfügt jeder Stapelrahmen auch über einen Konstantenpool (Laufzeitkonstantenpool), eine Ausnahmewurfverwaltung und andere Strukturen. Ich werde hier nicht auf Details eingehen, Sie können auf andere Informationen verweisen.

Lassen Sie uns anhand einer einfachen Demo die Funktionsweise eines Stapelrahmens veranschaulichen. Schauen wir uns zunächst eine solche Funktion an:

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

Der Bytecode, der der Logik innerhalb der Funktion entspricht, lautet wie folgt:

0: fload_1

1: fload_2

2: fcmpg

3: ifge 11

6: iconst_1

7: istore_3

8: gehe zu 13

11: iconst_2

12: istore_3

13: iload_3

14: ireturn

Lassen Sie mich diese Bytecode-Anweisungen kurz erläutern:

fload_x: Nehmen Sie die x-te Variable im lokalen Variablenarray, geben Sie fload ein und legen Sie sie auf den Stapel.

fcmpg: Vergleichen Sie zwei Gleitkommazahlen mit einfacher Genauigkeit. Wenn die beiden Zahlen größer als das Ergebnis sind, ist das Ergebnis 1, wenn sie gleich sind, ist das Ergebnis 0, wenn sie kleiner als das Ergebnis sind, ist das Ergebnis -1; >

iconst_x: Konstante x auf den Stapel schieben;

istore_x: den Stapel in das x-te lokale Variablenarray einfügen;

iload_x: das x-te lokale Variablenarray lesen und auf das schieben stack;

ireturn: gibt den Typ int am Ende der Funktion zurück

Wenn Sie genau hinschauen, können Sie feststellen, dass sich der Anfang von i auf int und der Anfang von f auf Load bezieht , Load stellt das Laden dar, if stellt einen Sprung usw. dar. Die Operationscode-Definition von Bytecode hat auch eine bestimmte Bedeutung und Details. Kann JVM-Bytecode-bezogene Standards übersetzen. Schauen wir uns an, wie jvm auf der Stack-Frame-Struktur ausgeführt wird, und nehmen wir als Beispiel den spezifischen Aufruf comp(1.02,2.02):

Java's Class

Wenn es um Bytecode geht, muss .class unverzichtbar sein. Sie können auch an einer Demo-Klasse teilnehmen, um den Inhalt der Klasse im Detail zu sehen. Eine der beiden Funktionen ist say und die andere ist die obige cmp-Funktion.

Verwenden Sie javac -g:none Hello.java, um diese Klasse zu kompilieren, und verwenden Sie dann javap -c -v Hello.class, um die kompilierte Klasse zu analysieren.

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;
    }
}

Erklären Sie die neuen Operationscodes

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 ]
}

Sie können die oben genannten Wörter im öffentlichen int comp(float, float)-Code sehen. Beispiel für die Codeausführung im Abschnitt. Mit einem perzeptiven Verständnis können Sie tatsächlich grob erkennen, dass die Klassendatei neben Bytecode-Anweisungen auch einen Konstantenpool, Zugriffsflags (öffentlich usw.) und klassenbezogene Informationen (Attribute, Funktionen, Konstanten usw.) enthält. . Da -g:node früher für die Kompilierung verwendet wurde, können in anderen Modi auch andere Erweiterungen und Debugging-Informationen in die Klasse eingebunden werden. Das offizielle Klassendateiformat lautet wie folgt:

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

magic: Es ist das sehr berühmte 0xCAFEBABE, eine Logo-Klassendatei;

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字符串解析。