Java-第十四部分-JVM-本地方法接口、本地方法栈和堆

99永远差一分
776 阅读18分钟

JVM全文

本地方法接口

  • 本地方法，一个native method就是一个java调用非java代码的接口，该方法的实现，并非java实现的
  • 本地方法接口，融合不同的编程语言为java所用，初衷是融合c/c++程序
  • native修饰的方法，有方法体，不是抽象方法，代码不是用java实现的
  1. 与java环境外交互，java应用需要与java外面的环境交互，与底层系统，如操作系统或某些硬件交换信息；本地方法正是一种交流机制，为我们提供了一些非常简洁的接口
  2. 与操作系统交互，底层为c/c++，jvm是依赖真实的操作系统，需要使用一些java没有提供封装的操作系统的特性
  3. Sun's java，sun的解释器是用c实现的，能像一些普通的c与外部交互，java需要调用c/c++的方法
  4. 改方法使用的越来越少，除非与硬件有关的应用，如java程序驱动打印机、系统管理生产设备

本地方法栈

  • 用于管理本地方法的调用，线程私有的
  • 允许被实现成固定或者可动态扩展的内存大小，存在StackOverflowError/OutOfMemoryError异常
  1. 线程请求分配的栈容量超过本地方法栈允许的最大容量
  2. 动态扩展时，在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的本地方法栈
  • 调用本地方法时，将本地方法压入本地方法栈，由执行引擎执行加载本地方法库
  • 当某一个线程调用一个本地方法时，它就进入一个全新的并且不再受虚拟机限制的世界，拥有和虚拟机同样的权限
  1. 通过本地方法接口来访问虚拟机内部的运行时数据区
  2. 可以直接使用本地处理器中的寄存器
  3. 直接从本地内存的堆中分配任意数量的内存
  • 并不是所有的jvm都支持本地方法，实现本地方法栈；在hotspo jvm，虚拟机栈和本地方法栈合二为一

堆

概述

  • 一个进程（每一个程序）中的多个线程共享一个堆空间
  • 一个jvm实例只存在一个堆内存，堆内存在jvm启动时就被创建，其空间大小也被确定，堆内存的大小是可以调节的
  • 堆可以处于物理上不连续的内存空间（虚拟内存可以根据物理内存建立一个映射，物理上不连续，虚拟内存可以连续），但在逻辑上是连续的
  • 所有线程都共享堆，在这里可以划分线程私有的缓冲区Thread Local Allocation Buffer, TLAB
  • 所有对象实例以及数组，都应该在运行时分配在堆上；数组和对象可能永远不会存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置
  • 方法结束后，堆中的对象不会马上被移除，仅仅在垃圾回收的时候才会被移除；堆是GC, Garbage Collection, 垃圾收集器执行垃圾回收的重点区域
  • 字符串常量池、静态变量

内存细分

  • 现代垃圾收集器大部分基于分代收集理论
  • jkd7之前，分为新生区/新生代/年轻代、养老区/老年区/老年代、永久区/永久代
  • jkd8之后，分为新生区/新生代/年轻代、养老区/老年区/老年代、元空间
  • 永久代/元空间并不完全属于堆，具体逻辑实现上属于方法区
  • 实际上堆的内存分配为新生代（eden space + survivor * 2）+老年代 image.png
  • 实际存放过程中eden space和任意一个survivor能存放类，而始终有一个survivor是空的，涉及到垃圾回收的复制算法

设置和查看堆的大小

  • 默认情况下，初始内存大小为物理电脑内存大小/64；最大内存大小为物理电脑内存大小/4。计算的内存大小中，是少一部分survivor的大小，因为垃圾回收的复制算法导致两个survivor，始终有一个是不能被用到的
//虚拟机中堆初始内存总量
long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
//虚拟机中堆最大内存
long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
  • run->eidt configurations->modify options->add vm options->-Xms20m -Xmx20m
  1. -Xms设置堆区起始内存，等价于-XX:InitialHeapSize
  2. -Xmx设置堆区最大内存，等价于-XX:MaxHeapSize
  3. -XX:+PrintGCDetails，打印gc垃圾回收的细节
  4. -X jvm运行参数；ms memory start的缩写
  5. 通常将两个值设置为相同的值，避免调整堆内存的大小，造成系统额外的压力，提高程序性能
  • jps查看当前java程序的进程
  • jstat -gc 23372 查看某个进程内存使用情况 image.png
  • 一旦堆区的内存大小超过最大内存，抛出OutOfMemoryError: Java heap space

年轻代和老年代

  • 年轻代，youngGen = Eden + Survivor0/from + Survivor1/to
  1. 几乎所有的java对象都是在eden区被new出来的
  2. 绝大部分的java对象的销毁都在新生代进行，朝生夕死
  3. -Xmn100m设置新生代内存空间大小，如果同时设置了比例，且有冲突，以这个参数设置的大小为准，但是一般不设置
  • 老年代，OldGen
  • 设置新生代和老年代的比例
-XX:NewRatio=2 新生代占1 老年代占2 
默认值为2
  • jinfo -flag NewRatio 26371 控制台查看该进程的比例
  • 设置Eden和Survivor的比例
-XX:SurvivorRatio=8 8:1:1
默认显示的参数是8，但是实际上是6:1:1，需要显示指定
-XX:-UseAdaptiveSizePolicy 关闭自适应内存分配的策略，实际上是无效的，也是6:1:1
使用ParallelGC的情况下，不管是否开启了UseAdaptiveSizePolicy参数，默认Eden与Survivor的比例都为：6:1:1

image.png

  • jinfo -flag SurvivorRatio 26371 控制台查看该进程的比例
  • CMS垃圾回收器默认关闭，新生代比例默认就是8:1:1，实际上也是 image.png image.png
  • G1垃圾回收器默认是开启的，内存空间是灵活分配的，调节比例好像没什么用 image.png

对象分配过程

  • 垃圾回收，频繁在新生代收集，较少在老年代收集，几乎不在永久代/元空间收集
  • 一般过程
  1. new的对象先放eden区
  2. 当eden区填满后，进行垃圾回收YGC YoungGC，判断哪些对象需要回收；survivor0/survivor1被填满不会触发YGC，YGC会对eden和survivor0/survivor1都进行垃圾回收
  3. 将留下的对象转移到survivor0，并附上年龄计数器
  4. 继续生成对象，重复第2步，并将剩下的对象转移到survivor1中，此时survivor1为空的空间(to空间)
  5. 对survivor0中的对象进行YGC，将剩下的对象再转移到survivor1，年龄计数器+1
  6. 每次YGC执行完后，survivor0/survivor1中为空的空间为to
  7. 当年龄计数器达到某个值（阈值）后，需要进行晋升，将对象转移到OldGen
  8. 阈值设置 -XX:MaxTenuringThreshold=<N>，默认是15
  9. 当老年代满时，触发MGC Major GC，进行内存清理；如果此时无法进行对象保存，产生OOM异常
  • 整体过程 image.png
  1. YGC后，eden仍然放不下超大对象，直接放到OldGen
  2. 如果老年代也放不下，MGC/FGC老年代垃圾回收
  3. 如果MGC/FGC后，老年代也放不下，抛出OOM异常
  4. YGC后，survivor0/survivor1放不下，直接晋升放在OldGen

垃圾回收

  • 针对HotSpot VM，按照回收区域，分为两大类，部分收集Partial GC；整堆收集Full GC
  • 部分收集
  1. 新生代收集，Minor GC / Young GC，只是新生代的垃圾收集，且只有Eden满时才触发
  2. 老年代收集，Major GC / Old GC，老年代的垃圾收集，只有CMS GC会有单独收集老年代的行为
  3. 混合收集，Mixed GC，收集整个新生代以及部分老年代的垃圾收集，目前只有G1 GC会有这种行为
  • 整堆收集，Full GC，收集整个java堆和方法区/元空间的垃圾收集
  • 年轻代GC
  1. Eden满触发
  2. 非常频繁，回首速度很快
  3. 会引发STW Stop The World，暂停其他用户的线程，等待垃圾回收结束，用户线程才恢复运行
  • 老年代GC
  1. 发生在老年代的GC，Major GC / Full GC都会导致老年代中对象减少
  2. 进行Major GC之前，经常会进行Minor GC，但在Parallel Scavenge收集器的收集策略中是直接进行Major GC
  3. 在老年代空间不足时，会先尝试触发Minor GC，之后空间还不足，触发Major GC，针对于一个对象放不下年轻代，直接放老年代的情况，清理空间，看对象能不能放入年轻代
  4. Major GC速度一般比Minor GC慢10倍以上
  5. Major GC之后，内存还不足，抛出OOM异常
  • Full GC，开发和调优中要尽量避免
  1. 调用System.gc()，系统建议执行Full GC，手动调用
  2. 老年代空间不足
  3. 方法区空间不足，动态类加载过多
  4. Minor GC之后，进入老年代的对象平均大小大于老年代可用内存
  5. 由Eden和from向to复制时，对象大小大于to，则需要把该对象转移到老年代，但是对象大小也大于老年代的内存大小
  6. 老年代连续空间不对
  7. 年代代放不下的超大对象，直接进入老年代，但是空间不足
  8. 过早提升导致的提升失败，由5可能性，对象放不下to区，但是放得下老年代中，导致老年代中短期存活对象的增长，此时，老年代放不下达到阈值的对象

分代思想

  • 不同对象的生命周期不同，为了优化GC性能，可以对不同生命周期的对象进行不同的处理
  • 如果没有分代，每次都要扫描堆的所有区域
  • 如果分代，将新创建的对象放在某一个地方，GC后，就将这块存储朝生夕死对象的区域进行回收，腾出空间

内存分配策略

  • 对象提升规则
  • 优先分配到Eden
  • 大对象直接分配到老年代，需要比较长的连续的内存的对象，尽可能避免出现过多的大对象
  • 长期存活的对象分配到老年代
  • 动态年龄判断，如果Survivor中相同年龄的所有对象大小总和大于Survivor空间的一半，年龄大约或等于该年龄的对象可以直接进入老年代无需达到阈值
  • 空间分配担保 -XX:HandlePromotionFailure，大量对象在GC之后存活，将Survivor的对象转移到老年代
  • TLAB，Thread Local Allocation Buffer
  1. 堆区是线程共享区域，任何线程都可以访问到堆区中的共享数据
  2. 由于对象实例的创建非常频繁，因此在并发环境下从堆区中划分内存空间是线程不安全的
  3. 为了避免多个线程操作同一地址，需要使用加锁等机制，但是会影响分配速度
  4. 在Eden中为每个线程分配了一个私有的缓存区域TLAB，多线程同时分配内存时，避免线程不安全的问题，提升内存分配的吞吐量，也就是快速分配策略
  5. -XX:+/-UseTLAB 设置是否开启TLAB空间，默认开启
  6. 默认情况下，TLAB空间非常小，仅占Eden空间的1%
  7. -XX:TLABWasteTargetPercent设置TLAB空间，-XX:TLABWasteTargetPercent=2
  8. 一旦对象在TLAB空间分配内存失败，会直接尝试通过加锁机制确保数据操作的原子性，直接在Eden空间中分配内存 image.png

特例

  • Eden区过大，导致S1/S0空间过小；当进行Minor GC，对象无法转移到S1/S0，会直接进入老年代，那么Minor GC就没有什么意义，也淡化了分代的作用
  • S1/S0过大，YGC出现频率过高，产生STW，影响用户进程

堆空间参数设置

  • -XX:+PrintFlagsInitial 查看所有参数的默认值
  • -XX:+PrintFlagsFinal 查看所有参数的最终值，设置后的值
  • -Xms<size> 初始堆空间内存
  • -Xmx<size> 最大堆空间内存，与Xms设置成相同的值，为了能够在java垃圾回收机制清理完堆区后不需要重新分隔计算堆区大小，提高性能
  • -Xmn<size> 新生代大小
  • -XX:NewRatio=2 新生代与老年代在堆结构的比例
  • -XX:SurvivorRatio=8 Eden:S0:S1
  • -XX:MaxTenuringThreshold=<N> 新生代垃圾的最大年龄
  • -XX:+PrintGCDetails 输出详细GC处理日志 打印简要信息 -XX:PrintGC / -verbose:gc
  • -XX:HandlePromotionFailure=true/false 是否设置空间分配担保，允许晋升失败，jdk7之后失效，
  1. 发生在Minor GC之前，检查老年代的最大可用连续空间是否大于新生代所有对象的总空间，如果大于，则安全；
  2. 如果小于，如果设置为true，检查老年代最大可用空间是否大于历次晋升到老年代的对象的平均大小
  3. 如果大于，表示大概率放得下，则尝试Minor GC，有风险
  4. 如果小于，表示大概率放不下，则改为Full GC，
  5. 如果设置为flase，进行Full GC
  6. jdk7之后，只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC，否则进行Full GC

堆是分配对象存储的唯一选择吗

  • 答，是又不是，将非逃逸对象进行标量替换，放在栈上，但是此时已经不是对象
  • 逃逸分析技术成熟，栈上分配/标量替换优化技术，但是无法保证逃逸分析的性能消耗后，能带来一定的优化
  • 如果经过逃逸分析后，一个对象并没有逃逸出方法，可能被优化成栈上分配，无需进行垃圾回收
  • TaoBaoVM中GCIH GC invisible heap实现off-heap，将生命周期较长的对象移动至堆外，并且GC不能管理GCIH内部的对象，降低GC的回收频率
  • 逃逸分析，减少java程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法；new的对象实体是否可能在方法外被调用
  1. 能够分析出一个新的对象的引用的使用范围，从而决定是否将这个对象分配到堆上
  2. 基本行为就是分析对象动态作用域
  3. 当一个对象在方法中被定义后，对象只在方法内部使用，则认为没有发生逃逸，对象放在栈空间，方法执行结束后，栈空间就被移除
  4. 当一个对象在方法中被定义后，被外部方法引用，发生逃逸，作为调用参数传递到其他方法
  5. jdk7后，默认开启逃逸分析 -XX:+DoEscapeAnalysis 开启逃逸分析；-XX:+PrintEscapeAnalysis查看逃逸分析结果，只在debug版本下可以使用
  6. 逃逸分析不能在静态编译时进行，必须在JIT即时编译时完成。原因是，与java的动态性有冲突，在运行时，通过动态代理改变一个类的行为，静态编译时无法知道类变化
  • 只有在server模式下，才可以启用逃逸分析，客户端上默认就是server模式

代码优化

  • 栈上分配，一个对象经过逃逸分析后，永远不会逃逸，就可能被优化成栈上分配

逃逸场景：成员变量赋值、方法返回值、实例引用传递

  • 同步省略，如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步
  1. 线程同步的代价相当高，后果是降低并发性和性能
  2. 借助逃逸分析来判断同步块所使用的锁对象是否只能够被一个线程访问，而没有被发布到其他线程，如果没有，JIT编译器，在编译这个同步块的时候就会取消对这部分代码的同步，锁消除/同步省略
  3. 字节码文件中仍然会有，只是到运行时可能会被省略
  • 分离对象或标量替换，有的对象可能不需要作为一个连续的内存结构也可以被访问到，那么对象的部分（或者全部）可以不存在堆内存中，而是存在栈中
  1. 标量，无法分解成更小的数据的数据，java中的原始数据类型
  2. 聚合量，还可以分解的数据，java中的对象
  3. 经过逃逸分析，发现一个对象不会被外界访问，经过jit优化，就会把这个对象拆解成若干个成员变量来替代
  4. 减少对内存的占用
  5. -XX:+EliminateAllocations，默认是开启的，允许将对象打散分配到栈上
  • 实际上，hotspot vm 并没有进行栈上分配，而是使用了标量替换
  • intern字符串（字符串常量池）和静态变量在jdk7之前分配在永久代上，之后直接在堆上分配，对象实例都是分配在堆上

堆空间共享问题

  • 采用CAS compare and swap理论配上失败重试保证更新的原子性
  • 每个线程预先分配一块TLAB空间，线程私有
  • CAS
  1. CAS操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值；否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。（在 CAS 的一些特殊情况下将仅返回 CAS 是否成功，而不提取当前值。）
  1. CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”
  1. 通常将 CAS 用于同步的方式是从地址 V 读取值 A，执行多步计算来获得新值 B，然后使用 CAS 将 V 的值从 A 改为 B。如果 V 处的值尚未同时更改，则 CAS 操作成功。
  1. 类似于 CAS 的指令允许算法执行读-修改-写操作，而无需害怕其他线程同时修改变量，因为如果其他线程修改变量，那么 CAS 会检测它（并失败），算法可以对该操作重新计算。
  • CAS的问题
  1. ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。
  1. 循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。
  1. 只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。
avatar
文章
阅读
粉丝