1.1.1 JAVA程序运行原理解析

前言

文章中的大部分图片来自：网易云课堂-java高级开发工程师

本文作为课后总结，从基本的class文件入手，分析class文件的组成和结构，从而了解java程序的运行原理。

正文：

• 一、class文件内容

class文件包含java程序执行的字节码；数据严格按照格式紧凑排列在class文件中的二进制流，中间无任何分隔符；文件开头有一个0xcafebabe(16进制)特殊的一个标志。

我们 可以通过打开一个class文件来查看它的16进制编码。如果没有这个开头的话，则jvm不能认证通过。

那么我们如何把class文件中的内容转化为方便人阅读的文本呢？

其实，在jdk中提供了这种命令： 

javap -v xxx.class > xxx.txt

这里注意编译class文件的jdk版本是否一致，否则会产生一个0kb的文件。

接下来我们把原java文件，和txt文件进行一个对比：

public class Demo {
    
    public static void main(String[] args) {
        int x = 500;
        int y = 100;
        int a = x / y;
        int b = 50;
        System.out.println(a + b);
    }

}

Classfile /D:/workspaces/MyEclipse Professional 2014/.metadata/.me_tcat7/webapps/monitor_server/WEB-INF/classes/Demo.class
  Last modified 2019-8-4; size 574 bytes
  MD5 checksum 59c5e86e65f30445d89dca7f1067f090
  Compiled from "Demo.java"
public class Demo
  SourceFile: "Demo.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER

Constant pool:
   #1 = Class              #2             //  Demo
   #2 = Utf8               Demo
   #3 = Class              #4             //  java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Methodref          #3.#9          //  java/lang/Object."<init>":()V
   #9 = NameAndType        #5:#6          //  "<init>":()V
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               LDemo;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Fieldref           #17.#19        //  java/lang/System.out:Ljava/io/PrintStream;
  #17 = Class              #18            //  java/lang/System
  #18 = Utf8               java/lang/System
  #19 = NameAndType        #20:#21        //  out:Ljava/io/PrintStream;
  #20 = Utf8               out
  #21 = Utf8               Ljava/io/PrintStream;
  #22 = Methodref          #23.#25        //  java/io/PrintStream.println:(I)V
  #23 = Class              #24            //  java/io/PrintStream
  #24 = Utf8               java/io/PrintStream
  #25 = NameAndType        #26:#27        //  println:(I)V
  #26 = Utf8               println
  #27 = Utf8               (I)V
  #28 = Utf8               args
  #29 = Utf8               [Ljava/lang/String;
  #30 = Utf8               x
  #31 = Utf8               I
  #32 = Utf8               y
  #33 = Utf8               a
  #34 = Utf8               b
  #35 = Utf8               SourceFile
  #36 = Utf8               Demo.java
{
  public Demo();
    flags: ACC_PUBLIC

    Code:
      stack=1, locals=1, args_size=1
         0: aload_0       
         1: invokespecial #8                  // Method java/lang/Object."<init>":()V
         4: return        
      LineNumberTable:
        line 2: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
               0       5     0  this   LDemo;

  public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=3, locals=5, args_size=1
         0: sipush        500
         3: istore_1      
         4: bipush        100
         6: istore_2      
         7: iload_1       
         8: iload_2       
         9: idiv          
        10: istore_3      
        11: bipush        50
        13: istore        4
        15: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
        18: iload_3       
        19: iload         4
        21: iadd          
        22: invokevirtual #22                 // Method java/io/PrintStream.println:(I)V
        25: return        
      LineNumberTable:
        line 5: 0
        line 6: 4
        line 7: 7
        line 8: 11
        line 9: 15
        line 10: 25
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
               0      26     0  args   [Ljava/lang/String;
               4      22     1     x   I
               7      19     2     y   I
              11      15     3     a   I
              15      11     4     b   I
}

示例环境：win10系统 

java版本：

java version "1.7.0_80"
Java(TM) SE Runtime Environment (build 1.7.0_80-b15)
Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)

• 二、class内容解析

1、头部信息

public class Demo
  SourceFile: "Demo.java"
  minor version: 0 // 次版本号
  major version: 51 // 主版本号
  flags: ACC_PUBLIC, ACC_SUPER // 访问标志

 

2、常量池

类里如果定义了静态常量，就能在这里确认到：

3、构造方法

这里虽然在类中没有定义构造方法，但是会默认生成一个隐式的无参构造函数。

3、方法

flags: ACC_PUBLIC, ACC_STATIC // 访问控制

stack=3, locals=5, args_size=1 // 本地变量数量=3，参数数量=5，方法对应栈帧中操作数栈的深度=1

         0: sipush        500
         3: istore_1      
         4: bipush        100
         6: istore_2      
         7: iload_1       
         8: iload_2       
         9: idiv          
        10: istore_3      
        11: bipush        50
        13: istore        4
        15: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
        18: iload_3       
        19: iload         4
        21: iadd          
        22: invokevirtual #22                 // Method java/io/PrintStream.println:(I)V
        25: return 

这几行，都是jvm的指令码。在class文件中这里不会有英文单词，而是以指令码来代替。

前面的数字，是偏移量（字节），jvm根据这些偏移量区分不同的命令。

下面的主要内容：简述这个方法中的指令与JVM的交互

JVM中class的初始状态：

0: sipush        500

3: istore_1

4: bipush        100

6: istore_2

7: iload_1       
8: iload_2       

9: idiv

10: istore_3

11: bipush        50

13: istore        4

15: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;

18: iload_3

19: iload         4

21: iadd

22: invokevirtual #22                 // Method java/io/PrintStream.println:(I)V

这里开始调用新的方法和方法栈（System.out.println方法），没有操作main方法栈。

25: return

以上就是方法中指令码的说明，当JVM读取class文件时，就会按照这些指令进行执行。这里同时也表现了程序计数器、虚拟机栈、线程独占空间的作用，而这三样则是在JVM中运行的，那么JVM在运行中的基本结构又是什么样的呢？

• 三、JVM的内存结构

1、程序计数器（Program Counter Register）：记录当前线程执行字节码的位置，存储的是字节码指令地址，如果执行Native方法，则计数器值为空。每个线程都在这个空间有一个私有的空间，占用内存空间很少。CPU同一时间，只会执行一条线程中的指令。JVM多线程会轮流切换并分配CPU执行时间的方式。为了线程切换后，需要通过程序计数器，来恢复正确的执行位置。

2、虚拟机栈：每个线程都在这个空间有一个私有的空间。线程栈由多个栈帧（Stack Frame）组成。一个线程会执行一个或多个方法，一个方法对应一个栈帧。栈帧内容包含：局部变量表、操作数栈、动态链接、方法返回地址、附加信息等。栈内存默认最大是1M，超出则抛出StackOverflowError

3、本地方法栈：和虚拟机栈功能类似，虚拟机栈是为虚拟机执行JAVA方法而准备的，本地方法栈是为虚拟机只用Native本地方法而准备的。虚拟机规范没有规定具体的实现，由不同的虚拟机厂商去实现。HotSpot虚拟机中虚拟机栈和本地方法栈的实现是一样的。同样，超出大小以后也会抛出StackOverflowError。

注：Native修饰符一般用来调用c/c++的方法。

4、方法区：JVM用来存储加载的类信息、常量、静态变量、编译后的代码等数据。虚拟机规则中这是一个逻辑区划。具体实现根据不同虚拟机来实现。如：oracle的HotSpot在java7中方法去放在永久代，java8放在元数据空间，并且通过GC机制对这个区域进行管理

5、堆内存：

堆内存还可以细分为：老年代、新生代（Eden、From Servivor、To Survivor）

JVM启动时创建，存放对象的实例。垃圾回收器主要就是管理堆内存。如果满了，就会出现OutOfMemoryError。

 

6、线程独占：每个线程都会有它独立的空间，随线程生命周期而创建和销毁

7、线程共享：所有线程能访问这块内存数据，随虚拟机或者GC而创建和销毁