1.内存结构

  • jvm 的内存
    • 栈 - 线程私有的(每个线程有自己的栈内存)
      • 程序计数器 （记录当前线程中代码执行的位置）
      • 本地方法栈 (native ) 非java语言编写的方法
      • 栈帧多个 每个栈帧对应一次方法调用, 方法内局部变量、方法参数，方法调用时分配栈帧内存，方法调用结束，栈帧内存被回收
    • 堆 - 线程共享的
      • 当新建一个对象时，对象使用的就是堆内存, 当多个线程访问堆中的对象时，需要注意线程安全问题
      • 数组用的也是堆内存
      • java 7 以后，字符串池，也也使用了堆内存（之前串池用的是方法区内存）
      • 从垃圾回收角度，分为 新生代（伊甸园、幸存区2个），老年代
      • 新生代有一个特殊部分 大小大约是整个新生代的 1% TLAB 每个线程可以新生代中申请一块内存(tlab), 是此线程私有的，其他线程不能访问, 在tlab内创建对象不需要加锁, 用来提升对象创建的效率
    • 方法区 - 线程共享的 (java 7 它实现叫做永久代 )
      • 常量池 - 串池 - 从 java 7 开始，使用了堆内存
      • 静态变量 - 从 java 7 开始，使用了堆内存
      • 类的定义信息 - 类的方法、属性、构造代码、类加载器
      • 即时编译器(JIT)生成的代码
        *.java -> *.class -> 解释/热点代码编译机器码
  • 非虚拟机内存(非堆内存)
    • jdk 8 开始，移除了永久代，换为了元空间(meta space)
    • 例如整个机器8g内存，jvm占了500m，其他程序占了500m，剩下的7g的内存都可被元空间使用

2. 垃圾回收

如何判断是否是垃圾

使用可达性分析算法判断此对象是不是垃圾（不能利用引用计数法，因为它存在循环引用的问题）

必须找到一个肯定不会被回收的对象(GC ROOT)，沿着这个对象的引用进行查找，查找不到可以标记为垃圾

垃圾回收算法

  • 标记 + 清除
  • 标记 + 整理
  • 拷贝

jvm 采用的是 分代垃圾收集
新生代(伊甸园， 幸存区) - 主要采用的就是拷贝算法
老年代(标记 + 清除 或标记 + 整理)

垃圾回收器

  • Serial 工作在新生代 （单线程）- 使用拷贝算法

  • SerialOld 工作在老年代 （单线程）- 标记 + 整理

  • ParNew 新生代 （多线程） - 使用拷贝算法 - 必须是在多个cpu 下才能充分发挥性能

  • CMS 工作在老年代（多线程）- 工作在老年代 - 标记 + 清除的算法（对响应时间有要求，多个cpu的环境下）
    容易产生内存碎片 java9

  • Parallel Scavenge （多线程） 新生代 使用拷贝算法 吞吐量优先

  • Parallel Old （多线程） 老年代 标记 + 整理 吞吐量优先

响应时间优先 每一次的响应时间最小
吞吐量优先 总的响应时间最小

300m 1ms 一分钟内进行了5次 5ms
600m 2ms 一分钟内进行了2次 4ms
内存小相对回收速度快
java 8 G1 已经有了，但不是默认的
Java 11 G1 垃圾回收器 ，变为默认的了

1.1 内存的分配回收策略

  1. 逃逸分析
    发现对象不会逃逸出方法，就会采用优化措施，让创建对象不会浪费堆内存，会采用标量替换将对象的属性操作变为方法内局部变量的操作
    在这个方法经过很多次调用，成为“热点”方法后才会采用上述优化
  2. TLAB
    是 伊甸园 中的一块特殊区域，是线程私有的，对象优先利用 tlab内存进行分配，好处是分配是不用加锁，效率高
  3. 伊甸园
    如果 tlab 内存不足, 对象就会利用伊甸园内存，需要加锁，效率相对较低
  4. 大对象
    对象优先会在伊甸园中分配，但对象如果比较大，新生代的空闲空间无法容纳这个对象，这时对象会使用老年代内存进行分配
  5. 多次幸存的对象晋升至老年代
    最大值 15 次
  6. 老年代连续内存空间不够，就触发 full gc
    full gc的暂停时间远远高于 minor gc

《深入理解jvm虚拟机》第三版 周志明

1.2 类加载

  1. 加载
    方法区(1.7之前叫永久代，从1.8开始叫元空间)

NoClassDefFoundError 没有类定义被找到 发生在类加载阶段，加载类B时，用到了另一个类A，但当前的类路径下找不到A就会发生这个错误

ClassNotFoundException 类没有被找到异常 发生在类加载阶段 加载类C时，C自己不存在，会报刚刚这个异常

  • 把类字节码加载至元空间
  • 形成一个 Class 类对象
  • 把该类关联的其他类（例如父类）连带进行类加载
  1. 链接
    cafe babe 版本 jvm二进制字节码指令
  • 保证类字节码的正确性，以及安全性
  • 分配静态变量的内存空间
  • 解析符号引用和常量
  1. 初始化
    收集所有 static 代码块和 静态变量赋值的语言（按从上至下的顺序）形成一个特殊的构造构造方法
    然后以线程安全的方式来执行这个特殊构造

初始化的触发时机

不会触发类的初始化有如下情况:

  • 使用该类的 static final 常量
  • 使用该类.class
  • 创建类的数组时

1.3 类的双亲委派加载机制

  • 启动类加载器（Bootstrap ClassLoader）：C++实现，在java里无法获取，负责加载jdk jre/lib 中核心的类，例如：rt.jar(java.lang., java.util.)。
  • 扩展类加载器（Extension ClassLoader）： Java实现，可以在java里获取，加载jdk jre/lib/ext 扩展目录下的类
  • 系统类加载器/应用程序类加载器（Application ClassLoader）：是与我们接触对多的类加载器，我们写的代码默认就是由它来加载，负责加载 classpath 下的所有类。

注意：

假设要对一个Student 进行类加载，加载流程是：
应用程序类加载器.loadClass()
委托父亲 - 扩展类加载器 找 student - 没有找到
委托父亲 - 启动类加载器 找 student - 没有找到
两个父亲都没有找到，才由自己到 classpath 最终找到了 Student
如果没有这套委派机制，就可能造成级别低的类加载器加载更通用的类（String.class),造成其他使用String的代码不能正常工作
像String这种比较通用的类应该由更高级别的类加载器去加载

1.4 hashmap原理

  • 接上一篇的补充————>>>

    1.7 如果发生了冲突，新元素会放在链表头
    1.8 如果发生了冲突，新元素会放在链表尾

    a -> 97 -> 1
    (a).equals(a)

    初始大小是 16 ， 当元素超过了初始大小的 3/4， 就会发生扩容

    1.7 扩容后链表的顺序会颠倒
    1.8 扩容后链表的顺序会保持
    1.8 后对链表长度控制有新的优化
    当链表长度过长时，会首先执行扩容
    当扩容的大小超过64时，就不会使用扩容减少链表长度了
    在链表长度大于等于8时，会把链表变为一个搜索二叉树(红黑树)

    ddos 攻击 精心生成一大批hash相同的字符串

    new HashMap(32);

    16 12

    24 * 4 / 3

    总结，面试时的常见问题：

    1. HashMap 底层的数据结构 (数据+链表+红黑树)
    2. 负载因子 是干嘛的 （决定了扩容的一个因素）
    3. 扩容，容量翻倍，遍历原来的链表，重新计算hashcode和桶下标，
      然后把桶下标发生改变的元素迁移到新的位置
    4. 为什么hashmap的容量是 2^n
    0001 0001  17
0000 1111  15
------------
0000 0001   1
    1. hashmap 多线程访问时发生了扩容，会发生什么现象
      • 死链
      • 数据丢失