笔记2

博客

20. Java 内存模型

JVM自动内存分配管理机制的优缺点？

• 优点：提升 Java 开发效率
• 缺点：
  
  • 系统易发生 JVM 的堆内存异常，
  • 垃圾回收（GC）的方式不合适以及 GC 次数过于频繁等问题。

JVM 内存模型?

• JVM 内存模型主要分为堆、程序计数器、方法区、虚拟机栈和本地方法栈。
  

堆（Heap）

• JVM 内存中最大的一块内存空间，
• 该内存被所有线程共享，几乎所有对象和数组都被分配到了堆内存中。
• 堆被划分为新生代和老年代，
  
  • 新生代又被进一步划分为 Eden 和Survivor 区，
  • Survivor 由 From Survivor 和 To Survivor 组成
  • Java6：永久代在非堆内存区；
  • Java7：永久代的静态变量和运行时常量池被合并到了堆中；
  • Java8：永久代被元空间取代。
    

程序计数器（Program Counter Register）

• 一块很小的内存空间;
• 作用：记录各个线程执行的字节码的地址；
  
  • 如，分支、循环、跳转、异常、线程恢复等都依赖于计数器
• 实例：
  
  • 多线程下，执行的线程数量超过 CPU 数量时，线程之间会根据时间片轮询争夺 CPU 资源。
  • 一个线程的时间片用完/其它原因导致这个线程的 CPU 资源被提前抢夺，则这个退出的线程就需要单独的一个程序计数器，来记录下一条运行的指令。

方法区（Method Area）

• 很多开发者都习惯将方法区称为“永久代”，但两者并不等价
• 作用：
  
  • 用来存放已被虚拟机加载的类相关信息，
  • 包括类信息、运行时常量池、字符串常量池，
  • 类信息又包括了类的版本、字段、方法、接口和父类等信息。
• 方法区与堆空间类似，也是一个共享内存区，所以方法区是线程共享的
• Java8 为什么使用元空间替代永久代，这样做有什么好处呢？
  
  • （官方解释）
  • 移除永久代是为了融合 HotSpot JVM 与 JRockit VM 而做出的努力，因为 JRockit 没有永久代，所以不需要配置永久代。
  • 永久代内存经常不够用或发生内存溢出，爆出异常 java.lang.OutOfMemoryError:
    PermGen。这是因为在 JDK1.7 版本中，指定的 PermGen 区大小为 8M，由于
    PermGen 中类的元数据信息在每次 FullGC 的时候都可能被收集，回收率都偏低，成绩
    很难令人满意；还有，为 PermGen 分配多大的空间很难确定，PermSize 的大小依赖于
    很多因素，比如，JVM 加载的 class 总数、常量池的大小和方法的大小等。

虚拟机栈（VM stack）

• 线程私有的内存空间，它和 Java 线程一起创建。
  
  • 当创建一个线程时，会在虚拟机栈中申请一个线程栈，
• 作用：
  
  • 保存方法的局部变量、操作数栈、动态链接方法和返回地址等信息；
  • 参与方法的调用和返回。
• 每一个方法的调用都伴随着栈帧的入栈操作，方法的返回则是栈帧的出栈操作。

本地方法栈（Native Method Stack）

• 与 Java 虚拟机栈的功能类似
  
  • Java 虚拟机栈用于管理 Java 函数的调用，
  • 本地方法栈则用于管理本地方法的调用。
• 本地方法并不是用 Java 实现的，而是由 C 语言实现的。

JVM 的运行原理

• 示例代码

  • JVMCase.java

    public class JVMCase {
    // 常量
    public final static String MAN_SEX_TYPE = "man";
    // 静态变量
    public static String WOMAN_SEX_TYPE = "woman";
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("nick");
        stu.setSexType(MAN_SEX_TYPE);
        stu.setAge(20);
        JVMCase jvmcase = new JVMCase();
        // 调用静态方法
        print(stu);
        // 调用非静态方法
        jvmcase.sayHello(stu);
    }
    // 常规静态方法
    public static void print(Student stu) {
        System.out.println("name: " + stu.getName() + "; sex:" + stu.getSexType());
    }
    // 非静态方法
    public void sayHello(Student stu) {
        System.out.println(stu.getName() + "say: hello");
    }
    }

  • Student.java

    public class Student {
        String name;
        String sexType;
        int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getSexType() {
            return sexType;
        }
        public void setSexType(String sexType) {
            this.sexType = sexType;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }

• JVM 的整个处理过程

  • ① JVM 向操作系统申请内存，JVM 第一步就是通过配置参数或者默认配置参数向操作系统
    申请内存空间，根据内存大小找到具体的内存分配表，然后把内存段的起始地址和终止地址
    分配给 JVM，接下来 JVM 就进行内部分配。
  • ② JVM 获得内存空间后，会根据配置参数分配堆、栈以及方法区的内存大小。
  • ③ class 文件加载、验证、准备以及解析，其中准备阶段会为类的静态变量分配内存，初始化为系统的初始值（这部分我在第 21 讲还会详细介绍）。
    
  • ④ 完成上一个步骤后，将会进行最后一个初始化阶段。在这个阶段中，JVM 首先会执行构造器 方法，编译器会在.java 文件被编译成.class 文件时，收集所有类的初始化代码，包括静态变量赋值语句、静态代码块、静态方法，收集在一起成为 () 方法。
    
  • ⑤ 执行方法。启动 main 线程，执行 main 方法，开始执行第一行代码。此时堆内存中会创建一个 student 对象，对象引用 student 就存放在栈中。
    
  • ⑥ 此时再次创建一个 JVMCase 对象，调用 sayHello 非静态方法，sayHello 方法属于对象 JVMCase，此时 sayHello 方法入栈，并通过栈中的 student 引用调用堆中的 Student对象；之后，调用静态方法 print，print 静态方法属于 JVMCase 类，是从静态方法中获取，之后放入到栈中，也是通过 student 引用调用堆中的 student 对象
    

思考题？

• 问题：上文提到了堆内存中对象分配内存空间的过程，那如果有一个类中定义了 String a="b"和 String c = new String(“b”)，请问这两个对象会分别创建在 JVM 内存模型中的哪块区域呢？
• String a="b"可能创建一个对象或者不创建对象,如果"b"这个字符串在常量池里不存在会在常量池创建一个String对象"b",如果已经存在则a直接reference to这个常量池里的对象;
  String c= new String("b")至少创建一个对象,也可能两个,因为用到new关键字,会在堆内在
  创建一个的String对象,它的值是"b"。同时,如果"b"这个字符串在常量池里不存在,会在常量
  池创建这个一个String对象"b"。
• 
  

21. 深入JVM即时编译器JIT，优化Java编译

• 前端编辑：
  
  • .java 文件被编译成 .class 文件的过程，这个编译我们一般称为前端编译
• 运行时编译：
  
  • 运行时，JIT 或解释器会将 Java 生成的字节码转换成机器码，这个过程就叫运行时编译。

Java 从编译到运行的整个过程?

20200918143831978.png#pic_center未知大小

类编译

• 编译、反编译
  
  • 编译：.java 通过 JDK 中自带的 Javac 命令生成 .class。
  • 反编译：javap 命令行
• 前期编译过程包括词法分析、填充符号表、注解处理、语义分析以及生成 class 文件
• .class 文件结构
• 编译后的字节码文件主要包括常量池和方法表集合这两部分
  
  • 常量池：记录的是类文件中出现的字面量以及符号引用；
    
    • 字面常量包括字符串常量（例如 String str=“abc”，其中"abc"就是常量），声明为 final 的属性以及一些基本类型（例如，范围在 -127-128 之间的整型）的属性。
    • 符号引用包括类和接口的全限定名、类引用、方法引用以及成员变量引用（例如 String str=“abc”，其中 str 就是成员变量引用）等。
  • 方法表集合
    -方法的字节码、
    -方法访问权限（public、protect、prviate等）、
    -方法名索引（与常量池中的方法引用对应）、
    -描述符索引、
    -JVM 执行指令以及属性集合等。

类加载？

• 作用：类被创建实例或者被其它对象引用时，未加载过该类会通过类
  加载器将字节码文件加载到内存中。
• 不同的实现类由不同的类加载器加载
  
  • JDK 中的本地方法类一般由根加载器（Bootstrp loader）加载
  • JDK 中内部实现的扩展类一般由扩展加载器（ExtClassLoader ）实现加载
  • 程序中的类文件则由系统加载器（AppClassLoader ）实现加载。
• 在类加载后，class 类文件中的常量池信息以及其它数据会被保存到 JVM 内存的方法区中。

类连接？

• 类在加载进来之后，会进行连接、初始化，最后才会被使用。
• 连接过程包括验证、准备和解析三个部分。
  
  • 验证：验证类符合 Java 规范和 JVM 规范，在保证符合规范的前提下，避免危害虚拟机安全。
  • 准备：为类的静态变量分配内存，初始化为系统的初始值。
    
    • 对于 final static 修饰的变量，直接赋值为用户的定义值。
      例如，private final static int value=123，会在准备阶段分配
      内存，并初始化值为 123，
      private static int value=123，这个阶段 value 的值仍然为 0
  • 解析：将符号引用转为直接引用的过程。
    
    • 在编译时，Java 类并不知道所引用的类的实际地址，因此只能使用符号引用来代替。
    • 类结构文件的常量池中存储了符号引用，包括类和接口的全限定名、类引用、方法引用以及成员变量引用等。
    • 如果要使用这些类和方法，就需要把它们转化为 JVM 可以直接获取的内存地址或指针，即直接引用。

类初始化？

• 过程：JVM 首先将执行构造器 方法，编译器会在将 .java 文件编译成 .class 文件时，收集所有类初始化代码，包括静态变量赋值语句、静态代码块、静态方法，收集在一起成为 () 方法。

• 初始化类的静态变量和静态代码块为用户自定义的值，初始化的顺序和 Java 源码从上到下的顺序一致。

  • 示例 1

    private static int i = 1;
    static {
        i = 0;
    }
    public static void main(String[] args) {
        System.out.println(i);
    }
    // print: 0

  • 示例 2

    static {
        i = 0;
    }
    private static int i = 1;
    public static void main(String[] args) {
        System.out.println(i);
    }
    // print: 1

  • 示例 3 : 子类初始化时会首先调用父类的 () 方法，再执行子类的 () 方法
    Parent.java

    public class Parent {
    public static String parentStr = "parent static string";
    static {
        System.out.println("parent static fields");
        System.out.println(parentStr);
    }
    public Parent() {
        System.out.println("parent instance initialization");
    }
    }

  Sub.java

  public class Sub extends Parent {
  public static String subStr = "sub static string";
  static {
      System.out.println("sub static fields");
      System.out.println(subStr);
  }
  public Sub() {
      System.out.println("sub instance initialization");
  }
  public static void main(String[] args) {
      System.out.println("sub main");
      new Sub();
  }
  }

  输出

  parent static fields
  parent static string
  sub static fields
  sub static string
  sub main
  parent instance initialization
  sub instance initialization

  • JVM 会保证 () 方法的线程安全，保证同一时间只有一个线程执行。
  • JVM 在初始化执行代码时，如果实例化一个新对象，会调用 方法对实例变量进行初始化，并执行对应的构造方法内的代码。

即时编译？

• 即时编译：
  
  • 初始化完成后，类在调用执行过程中，执行引擎会把字节码转为机器码，然后在操作系统中才能执行。
  • 在字节码转换为机器码的过程中，虚拟机中存在的一道编译，就是即时编译。
• 发展
  
  • 热点代码：运行特别频繁的某个方法或代码块；
  • 初始，虚拟机中的字节码是由解释器（ Interpreter ）完成编译
  • 后期，为了提高热点代码的执行效率，在运行时，即时编译器（JIT）会把这些代码编译成与本地平台相关的机器码，并进行各层次的优化，然后保存到内存中。

即时编译器类型？