JVM入门

1、JVM位置

2、JVM体系结构

JVM调优99%在调方法区和堆，Stack，Native Method Stack，程序计数器不会有垃圾回收

3、类加载器

public class Car {
    public int age;
    //类是模板，所有getClass的同一个对象，对象是是具体的是咧
    public static void main(String[] args) {
        Car car1 = new Car();
        Car car2 = new Car();
        Car car3 = new Car();
        System.out.println(car1.hashCode());
        System.out.println(car2.hashCode());
        System.out.println(car3.hashCode());
        Class<? extends Car> aClass1 = car1.getClass();
        Class<? extends Car> aClass2 = car1.getClass();
        Class<? extends Car> aClass3 = car1.getClass();
        System.out.println(aClass1.hashCode());//和下面连个是同一个对象，
        System.out.println(aClass2.hashCode());
        System.out.println(aClass3.hashCode());

        //各类加载器
        ClassLoader sys = ClassLoader.getSystemClassLoader();
        System.out.println(sys);//AppClassLoader 应用程序类加载器（系统类加载器）
        System.out.println(sys.getParent());//ExtClassLoader 扩展类加载器 \jre\lib\ext
        System.out.println(sys.getParent().getParent());//null 启动类（根）加载器，c c++开发，无法获得 rt.jar

        ClassLoader loader = aClass1.getClassLoader();
        System.out.println(loader);//AppClassLoader 应用程序类加载器（系统类加载器）
        System.out.println(loader.getParent());//ExtClassLoader 扩展类加载器
        System.out.println(loader.getParent().getParent());//null 启动类（根）加载器，c c++开发，无法获得

    }
}

作用：加载class文件

1. 虚拟机自带的加载器
2. 启动类（根）加载器
3. 扩展类加载器
4. 应用程序类(系统类)加载器
5. 自定义加载器

3.1、双亲委派机制

当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载，自己才会去加载这个类。

APP(应用程序加载器)–>EXC（扩展类加载器）—B0OT（根）(最终执行)

• app:
• exc:\jre\lib\ext
• boot:rt.jar

1. 类加载器收到类加载请求

2. 将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类（根）加载器

3. 启动类（根）加载器检查是否能够加载当前这个类，能加载就结束，使用当前加载器，否则通知子类加载器加载

4. 重复步骤3，直到应用程序类（系统类）加载器（不考虑自定义加载器），还无法加载，就会抛出异常Class Not Found

   jvm不能直接调用c的方法，native method是java调用非java代码的接口，native method不是由java实现

   native 是用做java 和其他语言（如c++）进行协作时使用的，

作用：

1、防止重复加载同一个.class。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全。
2、保证核心.class不能被篡改。通过委托方式，不会去篡改核心.clas，即使篡改也不会去加载，即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个Class对象。这样保证了Class执行安全。

3.2、沙箱安全机制

沙箱：限制程序运行的环境

沙箱机制：将java代码限定在虚拟机jvm特定的运行范围中，并且严格限制代码对本地资源的访问，来保证代码的有效隔离，防止对本地系统造成破坏

组件：

• 字节码校验器(bytecode verifier)
• 类裝载器(class loader)
• 存取控制器(access controller) Robot类等
• 安全管理器(security manager)
• 安全软件包(security package) 数字签名（证书）等

3.3、Native

• 凡是带了native关键字的，说明java的作用范围达不到了，会去调用底层c语言的库!
• 会进入本地方法栈
• 调用本地方法本地接口 JNI (Java Native Interface)
• JNI作用:开拓Java的使用，融合不同的编程语言为Java所用!最初: C、C++
• Java诞生的时候C、C++横行，想要立足，必须要有调用C、C++的程序
• 它在内存区域中专门开辟了一块标记区域: Native Method Stack，登记native方法
• 在最终执行的时候，加载本地方法库中的方法通过JNI
• 例如：Java程序驱动打印机，管理系统，掌握即可，在企业级应用比较少

3.4、PC寄存器

程序计数器: Program Counter Register

3.5、方法区

Method Area

所有线程共享,所有字段和方法字节码，以及一些特殊方法，如构造函数,接口代码也在此定义。

简单说，所有定义的方法的信息都保存在该区域,此区域属于共享区间;

静态变量、常量、类信息(构造方法、接口定义)、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

static final Class模板 常量池

• jdk 1.7 1.8 字符串常量池在堆中，
• 方法区java8之前放在jvm内存中，由永久代实现，java8后由元空间实现，放在本地内存中
• 类信息在元空间中（metaspace），类信息在方法区，方法区在元空间

3.6、栈

先进后出

栈内存,主管程序的运行,生命周期和线程同步;
线程结束，栈内存也就是释放,对于栈来说,不存在垃圾回收问题
一旦线程结束，栈就Over!

每个线程一个栈，为方法准备的。栈里面放栈帧，栈帧可以看做是一个方法的调用。

栈帧包括：

• 局部变量表
  • 8大基本类型
  • 引用类型的对象引用 0xxx 指针指向堆
  • returnAddress类型是为字节码指令jsr、jsr_w和ret服务的，它指向了一条字节码指令的地址
• 操作数栈 例：1+2 先要把1和2找个地方放着，找个地方就叫操作数栈
• 动态链接 例：main方法里调用了test方法，"test()"这些符号是怎么了解到test方法的具体的，这就是动态链接
• 方法出口信息

8大基本类型+对象引用+实例的方法

3.7、三种JVM

●Sun公司HotSpot Java Hotspot™ 64-Bit Server VM (build 25.181-b13,mixed mode)
●BEA JRockit
●IBM J9VM
我们学习都是: Hotspot

3.8、堆

Heap, 一个JVM只有一个堆内存，堆内存的大小是可以调节的。
类加载器读取了类文件后，一般会把什么东西放到堆中?
类, 方法，常量,变量~，保存我们所有引用类型的真实对象;
堆内存中还要细分为三个区域:

• 新生区(伊甸园区) Young/New
• 养老区old
• 永久区Perm（JDK1.8中已经被移除，被方法区的元空间取代）

GC垃圾回收,主要是在伊甸园区和养老区~

假设内存满了,OOM,堆内存不够! java.lang.OutOfMemoryError:Java heap space
永久存储区里存放的都是Java自带的 例如lang包中的类 如果不存在这些，Java就跑不起来了
在JDK8以后，永久存储区改了个名字(元空间)

3.8.1、新生区

• 类:诞生和成长的地方，甚至死亡;
• 伊甸园，所有的对象都是在伊甸园区new出来的!
• 幸存者区(0,1)

3.8.2、永久区

这个区常驻内存，用来存放jdk自身携带的Class对象，Interface元数据，存储的是java运行时的一些环境或类信息，这个区域不存在垃圾回收，关闭jvm就会释放此区域内存

• jdk1.6 永久代，常量池在方法区中，方法区在jvm内存中
• jdk1.7 永久代，但是慢慢退化，常量池在堆中
• jdk1.8 无永久代，常量池在元空间，元空间在本地内存中，云空间也可以叫做非堆，但是还是属于堆

3.8.3、堆内存调优

命令参数详解

• -Xms设置初始化内存分配大小/164
• -Xmx设置最大分配内存，默以1/4
• -XX: +PrintGCDetails // 打印GC垃圾回收信息
• -XX: +HeapDumpOnOutOfMemoryError //oom DUMP

OOM

1. 调整堆内存大小:idea中VM options中

   -Xms:初始化内存分配大小=内存的1/64(默认)

   -Xmx:最大内存=内存的1/4(默认)

   修改： -Xms1024m -Xmx1024m -XX:+PrintGCDetails，PrintGCDetails:打印GC垃圾回收信息

public class Demo {
    public static void main(String[] args) {
        long l = Runtime.getRuntime().maxMemory();//字节
        System.out.println(l/1024/1024+"m");//最大内存=电脑内存的1/4
        long l1 = Runtime.getRuntime().totalMemory();//字节
        System.out.println(l1/1024/1024+"m");//初始化内存分配大小=电脑内存的1/64
    }
}

在一个项目中，突然出现了OOM故障,那么该如何排除 研究为什么出错~

• 能够看到代码第几行出错:内存快照分析工具，MAT, Jprofiler
• Dubug, 一行行分析代码!

MAT, Jprofiler作用

• 分析Dump内存文件，快速定位内存泄露问题
• 获得堆中的数据
• 获得大的对象

Jprofiler使用

1. idea安装插件Jprofiler

2. 往上下载jprofiler并安装

3. idea配置jprofiler

4. 代码

   public class TestOom {
       byte[] array = new byte[1024 * 1024];//1m
   
       public static void main(String[] args) {
           ArrayList<TestOom> list = new ArrayList<>();
           int count = 0;
   
           try {
               while (true) {
                   list.add(new TestOom());
                   count++;
               }
           } catch (Error e) {//OutOfMemoryError是错误，Exception捕获不到
               System.out.println(count);
               e.printStackTrace();
           }
       }
   }
   

5. 配置vm参数：-Xms1m -Xmx8m启动，让其报错：OutOfMemoryError: Java heap space

6. Dump文件命令

   修改vm参数：-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

   说明：报了OOM错误，就会把错误信息文件Dump下来

3.9、总结

jdk 1.8及以后

• 栈：基本类型，引用类型的引用

• 堆：线程共享，new 出来的对象实例，所有引用类型的真实对象

  • 新生代
    • Eden new 出的对象
    • 幸存区from
    • 幸存区to
  • 老年代

• 方法区 （非堆）：线程共享，静态变量，常量，类信息(构造方法、接口定义)，常量池，方法区由元空间实现，在元空间中

  1.8 之后，方法区与堆共享内存，逻辑认为在堆中

• 永久区

  • 元空间
    • 方法区（非堆）

永久区，元空间

1.8之前由永久代实现，在jvm内存中，

1.8之后由元空间实现，在本地内存中

1.6 有永久代 常量池在方法区中

1.7 有退化的永久代 常量池在堆中

1.8 元空间仍然与堆不相连，但与堆共享物理内存，逻辑上可认为在堆中

4、GC 垃圾回收机制

JVM在进行GC时，并不是对这三个区域统一回收，大部分 时候，回收的都是新生代

• 新生代
• 幸存区（from，to）
• 老年代

GC两种：轻GC（普通ＧＣ）， 重GC（全局GC）

GC的算法有哪些?

标记清除法，标记整理,复制算法，引用计数器

4.1、引用计数法

4.2、复制算法

GC时，活下来的对象Eden进入幸存to区，幸存区from复制到to区,此时from区变to区，to区变from区，15次GC后，对象还没死就进入养老区

• 好处:没有内存的碎片~

• 坏处:浪费了内存空间~ :多了一半空间永远是空to。假设对象100%存活(极端情况)

复制算法最佳使用场景:对象存活度较低的时候;新生区~

4.3、标记清除法

• 优点：不需额外空间
• 缺点：两次扫描，浪费时间，清楚后会产生内存碎片

标记压缩：为了解决标记清除算法产生的内存碎片，在清楚后增加一次扫描

总的叫：标记清除压缩算法，再优化，标记清除多次后再进行一次压缩

4.4、总结

• 内存效率：复制算法 > 标记清除算法 > 标记压缩算法（时间复杂度的问题）

• 内存整齐度：复制算法 = 标记压缩算法 > 标记清除算法

• 内存利用率：标记压缩算法 = 标记清除算法 > 复制算法

没有最好的算法，只有最合适的算法

GC—>分代收集算法

• 年轻代：存活率低，用复制算法
• 老年代：区域大，存活率高，标记清除 + 标记压缩混合实现

5、JMM

java memory model java内存模型

作用：

缓存一致性协议，用来定义读写的规则

JMM定义了线程工作内存和主内存之间的抽象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory）

解决共享对象可见性的问题：voliate，用了voliate就会吧对象刷新到主内存中，其他线程就可以读到