Java-基础-JVM&JMM

2020-02-24

字数统计: 4k字 | 阅读时长≈ 15分钟

JVM探究

请你谈谈对JVM的理解？ java8虚拟机和之前的变化更新？
什么是OOM,什么是栈溢出StackOverFlowError？怎么分析？
JVM的常用调优参数有哪些？
内存快照如何抓取，怎么分析Dump文件？
谈谈JVM中，你对类加载器的认识？

需要掌握的内容

1. JVM的位置

Jvm的位置

2. JVM的体系结构

体系架构

3. 类加载器

作用：加载class字节码文件

4. 类加载器的类别

4.1 BootstrapClassLoader（启动类加载器）

c++编写，加载java核心库 java.*,构造ExtClassLoader和AppClassLoader。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作

4.2 ExtClassLoader （标准扩展类加载器）

java编写，加载扩展库，如classpath中的jre ，javax.*或者
java.ext.dir 指定位置中的类，开发者可以直接使用标准扩展类加载器。

4.3 AppClassLoader（系统类加载器）

1	java`编写，加载程序所在的目录，如`user.dir`所在的位置的`class

4.4 CustomClassLoader（用户自定义类加载器）

java编写,用户自定义的类加载器,可加载指定路径的class文件

5. 双亲委派机制

5.1 作用：

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

5.2 定义：

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

类加载器收到类加载的请求
将这个请求向上委托给父类加载器去完成，一直向上委托
启动类加载器检查是否能加载当前这个类，能加载就结束，使用当前的加载器，否则抛出异常，通过子类加载器进行加载
重复步骤3

5.3 源码分析

protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 首先检查这个class是否已经加载过了
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    // c==null表示没有加载，如果有父类的加载器则让父类加载器加载
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        //如果父类的加载器为空 则说明递归到bootStrapClassloader了
                        //bootStrapClassloader比较特殊无法通过get获取
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {}
                if (c == null) {
                    //如果bootstrapClassLoader 仍然没有加载过，则递归回来，尝试自己去加载class
                    long t1 = System.nanoTime();
                    c = findClass(name);
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

6. 沙箱安全机制

什么是沙箱安全机制？
- Java安全模型的核心就是Java沙箱（sandbox）
- 什么是沙箱？沙箱是一个限制程序运行的环境。沙箱机制就是将 Java 代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。
- 沙箱主要限制系统资源访问，那系统资源包括什么？——CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。

7. Native

凡是带了native关键字的，表示java的作用范围达不到了，会去调用底层C语言的库！
会进入本地方法栈，会调用本地方法接口（JNI）
JNI的作用：扩展Java的使用，融合不同的编程语言为Java所用（最初：C，C++）
Java在内存区域中专门开辟了一块标记区域，Native Method Stack, 登记native方法
在最终执行的时候，加载本地方法库中的方法通过JNI

8. PC寄存器

程序计数器：Program Counter Register

每个线程都有一个程序计数器，是线程私有的，就是一个指针，指向方法区中的字节码文件（用来存储指向像一条指令的地址，也即将要执行的指令代码），在执行引擎读取下一条指令，是一个非常小的内存空间，可以忽略不计

9. 方法区

Method Area 方法区

方法区是被所有现场共享的，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义，简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间

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

用来存放

static
final
class
常量池

10. 栈

程序猿：数据结构 + 算法

码农：框架 + 业务逻辑

10.1 栈

栈：先进后出，后进先出（main方法先执行，最后结束~）
栈，栈内存主管程序的执行，生命周期和线程同步
线程结束，栈内存也就被释放了
对于栈来说，不存在垃圾回收问题（一旦线程结束，栈就Over）
栈：8大基本类型 + 对象的引用（地址） + 实例的方法（method）
原理：栈帧

10.2 队列

队列：先进先出（FIFO:First Input First Output）

喝多了吐就是栈，吃多了拉就是队列

10.3 栈溢出

//StackOverflowError
public class Zhan {
    public static void main(String[] args) {
        new Zhan().test();
    }


    public void test(){
        a();
    }

    public void a(){
        test();
    }
}

输出结果：

//栈溢出 ： 递归会有问题 StackOverflow
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)
	at Zhan.test(Zhan.java:8)
	at Zhan.a(Zhan.java:12)

10.4 栈 + 堆 + 方法区：交互关系

画出一个对象实例化的过程（在内存中）：百度看视频

11. 三种JVM

Sun公司 HotSpot

Oracle JRockit （原来的 Bea JRockit）电脑软件 (基本JRockit JVM是世界上最快的JVM)
IBMJ9 (https://www.zhihu.com/question/39780313?sort=created)

12. 堆

Heap：一个JVM只有一个堆内存，堆内存的大小是可以调节的

类加载器读取了类文件后，一般会把什么东西放到堆中？
- 类，常量，变量~
- 保存所有引用类型的真实对象

堆内存中还要细分为三个区域：

新生区（伊甸园区） Young/new
养老区 old
永久区

12.1 新生区，老年区，永久区

GC垃圾回收，主要实在伊甸园区和养老区

假设内存满了：OOM (堆内存不够：OutOfMemoryError)

在JDK8以后,永久存储区改了个名字（元空间）

12.2 新生区

类：诞生和成长的地方，甚至到死亡；
伊甸园，所有对象都是在伊甸园区new出来的
幸存者区（0，1）
真理：经过研究，99%的对象都是临时对象

12.3 永久区

这个区域常驻内存的，用来存放JDK自身携带的Class对象，Interface元数据，存储的使Java运行时的一些环境或类信息

这个区域不存在垃圾回收，关闭VM虚拟就会释放这个区域的内存

一个启动类，加载了大量的第三方jar包。Tomcat部署了太多的应用，大量动态生成的反射类。不断的被加载，直到内存满，就会出现OOM

jdk 1.6:永久代，常量池在方法区
jdk 1.7:永久代，但是慢慢退化了，去永久代，常量池在堆中
jdk 1.8:无永久代，常量池在元空间

元空间：逻辑上存在，物理上不存在

12.4 OOM Error

//OOM Error示例
import java.util.Random;

public class OOM {
    public static void main(String[] args) {
        String str = "Zhuuuu";

        while (true){
            str = str + new Random().nextInt(899888888) + new Random().nextInt(999999999);
        }
    }
}

输出：OutOfMemoryError

解决方法：

尝试扩大堆内存（如下所示看结果）
分析内存，看一下哪个地方出现了问题

12.5 IDEA调节虚拟机堆内存大小

配置如下代码：在Configuration中

1	-Xms8m -Xmx8m -XX:+PrintGCDetails

具体步骤如下图所示：

元空间：逻辑上存在，物理上不存在

12.6 扩展学习（Random.nextInt()）

/*
random.nextInt()的用法
1、不带参数的nextInt()会生成所有有效的整数（包含正数，负数，0）

2、带参的nextInt(int x)则会生成一个范围在0~x（不包含X）内的任意正整数

例如：int x=new Random.nextInt(100); 

则x为一个0~99的任意整数
　　　　
*/

13. 堆内存调优

13.1 Jprofiler

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

14. GC垃圾回收器

JVM在进行GC中，并不是对三个区域进行统一回收。大部分时候，回收的都是新生代
GC的两种类：
- 轻GC(普通的GC)
- 重GC(深度的GC)

14.1 GC的作用区域

14.2 GC面试题

JVM内存模型和分区详细到每个区放什么？
堆里面的分区有哪些？(Eden, from, to，老年区)
GC的算法有哪些？
- 标记清除法
- 标记压缩法
- 复制算法
- 引用计数器
轻GC和重GC分别用在什么时候？

14.3 GC 引用计数法

14.4 GC 复制算法

步骤：

from区把垃圾丢给to
Eden区把垃圾丢给to

优点：

没有内存的碎片

缺点：

浪费了内存空间，多了一半空间永远是空的

复制算法最佳场景使用：对象存活度较低的时候（新生区中使用最好）

14.5 GC 标记清除法

优点：不需要额外的空间
缺点：两次扫描，严重浪费时间，会产生内存碎片

14.6 GC 标记压缩法

14.7 GC算法总结

内存效率：复制算法>标记清除算法>标记压缩算法（时间复杂度）
内存整齐度：复制算法=标记压缩算法>标记清除算法
内存利用率：标记压缩算法=标记清除算法>复制算法

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

GC:分代收集算法

年轻代：

存活率低
复制算法

老年代：

区域大：存活率
标记清除（内存碎片不是太多） + 标记压缩混合实现

15. JMM

1. 什么是JMM?

Java 内存模型Java 内存模型（JMM）是一种抽象的概念，并不真实存在，它描述了一组规则或规范，
通过这组规范定义了程序中各个变量（包括实例字段、静态字段和构成数组对象的元素）的访问方式。
试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
注意JMM与JVM内存区域划分的区别：JMM描述的是一组规则，围绕原子性、有序性和可见性展开

2. JMM的作用?

作用：缓存一致性协议，用于定义数据读取的规则（遵守规则）

JMM定义了线程工作内存和主内存之间的抽象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存。
所有的变量都存储在主内存当中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。
线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。

解决共享对象可见性这个问题： volilate

3. JMM的规则

　内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可再分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

- lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
- unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
- read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
- load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
- use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
- assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
- store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
- write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

　JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

JMM对这八种操作规则和对volatile的一些特殊规则就能确定哪里操作是线程安全，哪些操作是线程不安全的了。但是这些规则实在复杂，很难在实践中直接分析。所以一般我们也不会通过上述规则进行分析。更多的时候，使用java的happen-before规则来进行分析。

4. JMM和JVM的内存区域划分区别

JMM描述的是一组规则，围绕原子性，有序性和可见性展开
相似点：存在共享区域和私有区域

16. 内存模型的三大特性

总结

学习方案

百度
思维导图

打赏

版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！