中信证券：促进汽车消费落地 推荐乘用车、重卡、新能源汽车龙头

来源：https://segmentfault.com/a/1190000014395186

工作之余，想总结一下JVM相关知识。干货比较多，内容比较长，好好看看。

然后就直入主题了——

Java运行时数据区：

Java虚拟机在执9 n P W t 9 v H行Java程序的过程中会将其管理的内存划分为若干个不同的数据区域，
这些区域有各自的用途、创建和销毁的时间，有些区域随虚拟机进程的启动而存 _ V 6 p j在，
有些区域则是依赖用户线程的启动和结束来建立和销毁。
Java虚拟机所管理的内存包括以下几个Z ` x ] D Z d运行时数据区域，如图：

1、程序计数器：指向当前线程正在执行的字节码指令。线程私有的。

2、G 1 C D = z W k P虚拟机栈：虚拟机栈是Java执行方法的内存模4 $ 2 U x 2型。每个方法被执行的时候，都会创建一个栈帧，把栈帧压人栈，当方法正常返回或者抛出未捕获的异常时，B l F w P _ %栈帧就会出栈。

（1）栈帧：栈帧存储方法的相关信息，包含局部变量数表、返回值、操作数栈、动态链接

a、局部Q / o变量表：包含了方法执行过程中的所有变量。局部变量数组所需要的空间在编译期间完成分配，在方法运行期间不会改变局部变量数组的大小O + o Z 8 ]。

b、返回值：如果有返回值的话，压入调用者栈帧中的操作数栈中，并且把PC的值Z E V / p T指向 方法调用指令 后面的一条指令地址。

c、操作数栈：操作变量的内存模型。操作数栈的最大深度在编译的时候已经确定（写入方法区code属性的max_stacks项中）。操作数栈& D `的的元素可以是任意Java类型，包括long和double，32位数据占用栈空间为1，64位数据占用2。方法刚开始执行的时候，栈是空的，当方法执行过程中，各种字节码指令往栈中存取数据。

d、动态链接：每个栈帧都持有在运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支S } ` = n持方法调用过程中的动态链接。

（2）线程私有

3、本地方法栈：

（1）调用本地native的内存模型

（2）线程独享。

4、方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译W - +后的代码等数据

（1）线程共享的

（2）运行时常A ^ l量池：

A、是方法区的一部分
B、存放编译期生成的各种字面量和符号引用
C、Class文Q u ; x P X件中除了{ # i  & { *动时创建
（4）此内存区域的唯一目的就是存放对象实例，几乎所有对象实例都在这里分配内存。存放new生成的对象b M C ) v和数组
（5）Java堆是垃圾收集器管理的内存区域，因此很多@ k Q c | t 1时候称为“GC堆”
JMM Java内存模型：
1、 Java的并发采用“共享内存”模型，线程之间通过读写内存的公共状态进行T V ]通讯。多个线程之间是不能通过直接传递数据交互的，它们之间交互只能通过共享变量实现。
2、 主要目的是定义程序# / E % ^ G s H |中各个变; { l A  /量的访问规则。
3、C * ( S { ~ p u Java内存模型规定所有变量都u ( l 9 % t _ B存储在主内存中，每个线程还有自己的工作内存。
（1） 线程的工作内存中保存了被该线程使用到的变量的拷贝（从主内存中拷贝过来），线程对变量的所有操作( Y 2 D [ k 7 2都必须在工作内存中执行，而不能直接访问主内存中的变+ x } _ a t Q量。
（2） 不同线程之间无H ! k c法直接访问对方工作内存的变量，线程间变量值6 i l m K ; y Z的传递都要通过主内存来完成。
（3） 主内存主R b  A要对应Java堆中实例数据部分。工作内存对应于虚拟机栈中部分区域。
4、Java线程之间的通信由内存模型JMM（Java Memory Model[ * D c  B t i X）控制。
（1）JMM决定一 p g  . D  6同一条线程执行多次，只有执行相同次数的unlock操作，V T _ 8 W `变量才会解锁
（6）如果对一个变量进行lock操作，将会清空工作内存] M ; S中此变量的值，在执行引擎使用这个变量前，需要重新执行load或者as1 o W y  + d $ v为8：1：1
（3）内存不足时发生Minor GC
2、老年代：
（1）采用标记-整理算法（mark-compact），原因是老年代每次GC只会回收少部分对象。
3、Perm：用来存储类的元数据，也就是方法m I m ? T区。
（1）Perm的废除：在jdk1.8中，Perm被替换成MetaSpace，MetaSp# } | j G Eace存放在本地内存中。原因是永久代进场内存不够用A v p，或者发生内存泄漏。
（2）MetQ { v  S K JaSpace（元空间）：元空间的本质和永久代类似，都是对JVM规l ` Q v范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在+ 9 C j p虚拟机中，而是使用本地内存。
4、堆内存的划b : % } D p *分在JVM里面的示意图：
GC垃圾回收：
一、 判断对象是否要回收的方法：可达性分析法
1、 可达性分析法：通过一系列? 6 M m O“q M T C z v S VGC Roots”对象作为起点: n # s进行搜索，如果在“GC Roots”和一个对象之间没有可达路径，则称该对象是不可达的。不可达对象不一定会成为可回收对象。进入DEAD状态的线程还可以恢复，GC不会回收它的内存。（把一些对象当做root对象，JVM认为root对象是不可回收的，并且rooV * B Q 7 7 4 Vt对象引用的对象也是不可回收的）
2、 以下对象会被认为是r/ Z 3 { + d 9 ]oot对象：
（1） 虚拟机栈（栈帧中本地变量表）中引用的对象
（2） 方法区中静态i % H v V a 3属性引用的对象
（3） 方法区中常量引用的对象
（4） 本地方法栈中Native方法引用的对象
3、 对象被判定可被回收，需要经历两个阶段：
（1） 第一个阶段是可达性分析，分析该对象是否可达
（2） 第二个阶段是当对象没有重写finalize()方法或者finalize()方法已经被调用过，虚拟机认为该对象不可以p = g 7 Q j U %被救活，因此回收该 ^ [ p W ) J对w 9 象。（finalize()方法在垃圾回收中的作用是，给该对象一次救活的机会）
4、 方法区中的垃圾回收：
（1） 常量池中一些常量、符号引=  0 ^ 5 ^ # ` W用没有被引用，则会i t ; Q 3被清理出常量池
（2） 无用的类：被判定为无用的K c `类，会被清理出方法区。判定方法如下：
A、 该类的所有实例被回收
B、 加载该类的ClassLoader被回收
C、 该类的Class对象没有被引用
5、 finalize():
（1） GC垃圾回收要回收一个对象的时候，调用该对象的finalize()方法。然后在下一次垃圾回收的时候，才去回收这个对象的内存。
（2） 可以在该方法里面，指定一些对象在释放前必须执行的操作。
二、 发现虚拟机频繁full GC时应该怎么办：
（full GC指的是清理整个堆空间，包括年轻代和永久代）
（1） 首先用命令查看触发GC的原因是什么 jstat –gccause 进程id
（2） 如果是System.gc()，则看下代码哪里调用了这个方法
（3） 如果是heap inspection(内存检查)，可能是哪里执行jmap –histo命令
（4） 如果是GC locker，可能是程序依赖的JNI库的原因
三、常F , j 3 2见的垃圾回收算法：
1、Mark-Sweep（标记-清除算法? , 5 n U | o）：
（1）思想：标记清除算法分为两个阶段，标记阶段和清除阶段。标记阶段任务是标记出所有需要回U c Y收的对象，清除阶l $ Y n M段就是清除被标记对象的空Q . & I , z =间。
（2）优缺点：实现简单，容易产生内存碎片
2、Copying（复制清除算法）：
（1）思想：将可用内存划分为大小相等的两块，每次只使用其中的一块。当进行垃圾回收的时候了，把其中存活对象全部复制到另外一块中，然后把已使用的内存空间4  ~ d ? t一次清空掉。
（2）优缺点：不容易产生内存碎片；可用内存空间少；存活对象多的话，效率低下。
3、Mark-Compact（标记A m L ? % g + l-整理算法）：
（1）思想：先标记存活对象，然后把存活对象向一边移动，然后清理掉端边界以外的内存。
（2）优缺点：不容易产生内存碎片；内存利用率高；存活对象多并且分散的时候+ n k (，移动次数多j M I ; ? P J & M，效率低下
4、分代收集算法：（目前大部分JVM的垃圾收集器所采用的算法）：
思想：把堆分成新生代和老年代。（永久代指的是方法区）
（1） 因为新生代每次垃圾回收都要回收大部分对象，所以新生代采用Copying算法。新生代里面分成一份f N S 6 C s较大的Eden空间和两份较小的Survivor空间。每次只使用Edenh _ P I 0 ; s {和其中一块Survivor空间，然后垃圾回收的时候，把存活对象放到未使用的Survivor（划分出from、to）空间中，清空Edev ? wn和刚才使用过的Survivor空间。, U m T l
（2） 由于老年代每次只回收少量的对象，因此采用mark-compact算法。
（3） 在堆区外有一个永久代。对永久代的回收主要是无效H ] N ~ | F {的类和常量
5、GC使用时对程序的影响？
垃圾回收会影响程序的性能，Java虚拟机必须要追踪运行程序中的有用对象，然后释放没用对象，这个过程消耗处理器时间6、几种不同的垃圾回收类型：
（1）Minor GC：从年轻代（包括Ede_ o C 8 Fn、Survivor区）回收内存。
A、当JVM无法为一个新的N I q i ) B A 对象分配内存的时候，越容易触发Minor GC。
所以分配 } w U N $率越高，内存越来越少，越频繁执行Minor GC
B、执行Minor GC操作的时候，不会影响到永久代（Tenured）。
从永久代到年轻代的引用，被当成GC Roots，
从年轻代到老年代的引用在标记阶段直接被忽略掉。; 2 ? F 3 q L ]
（2）Major GC：清理整个老年代，当eden区内存? l F (不足时触发。
（3）h ` 8 0 J - *Full GC：清理整个堆空间，包括年轻代和老年代。当老年代内存不足时触发
HotN - # +SpotG L ( i 虚拟机详解：
1、 Java对象创建过程：
（1）虚拟机遇到一条new指令时，首先检查这个指x W V _令的参数能否在常量池中定位到一个Z ~ 5 E 3 L k类的符号引用，并检查这个符号引用代表的类是否已经加载、连接和初始化。如果没有，就执行该类的加载过程。
（2）为该对象分配内存。
A、假设Java堆是规整的，所有用过的内存放在一边，空闲的内存放在另外一边，中间放着一个指针作为分界点的指示器。那分配内存只是把指H G d f P i #针向空闲空间那边挪动与对象大小相等的距离，这种分配称为“指针碰撞”
B、假设Java堆不是规整的，用过的内存和空闲的内存相互交错，那# % {就没办法进行“指针碰撞”。 p做法：+ - , ? @ ` 2 - L虚拟机使用CAS失败重试的方式保证更新操作的原子性。
（实际上还有另外一种方案：每个线程在Java堆中Y  8 y ?  D VXX:+/-UseTLABR ) ( M 3 % 9 L ;参数决定）
（3）虚拟机为分配的内存空间初始化为零值（默认值）
（4）虚拟机对对象进行必要的设置，例如@ 2 F K M f这个对象是哪个类的实例、如何才能找到对象的元数据信息、对象的Hash码、对象的GC分代年龄等信息。这些信息存放在对象的对象头中。
（J V S U b { % ! [5） 执行<init>方法，把对象按照程序员的意愿进行初始化。
2、 对象的定位访问的方式（通过引用如! @ 9 S H x何去定位到堆上的具* Y  POopMap，这些位置称为安全点。
B、程序执行过程中并非所有地方都可以停下来开a A s X始GC，只有在到达安k { $ Y P E 5 a全点是才可以暂停。
C、安全点的选定基本上以“是否具有5 * 9 F N U N e y让程序长时间执行“的特征选定的。比如说方法调用、循环跳转、异常跳转等。具有这些功能的指令才会产生Sa7 j G ,fepoint。
（3Q ( : * 2 ~  ）中断方式：
A、抢占式中断：在GC发生时，首先把所有线程中h e s u a e断，如果发现有线程不在安全点6  $上，
就恢复线程，让它跑到安全点上。
B、主动式中断：GC需要中断线程时( j (，不直接对线程操作G I i g d 2，
仅仅设置一个标志，各个线程执行时主动去轮询这个标志，
当发现中断标记为真就自己中断挂起。轮询标记的地方和安全点是重合的。
（5）安全区域：
一段代码片段中，对象的引用关Z j A x F系不会发生变化，在这个区域中任何地J C j W N (方开始GC都是安全的。在线程进入安全区域时，它首先标A ! = 9志自己已经进入安全区域，在这段时S J  n W o )）缺点：; ~ ] b H B
A! , p ,、对. 9 0 u f  X h UCPU / X ] i z I资源占用比较多。可能因为占用一部分CPU资源导致应用程序响应变慢。
B、CMS无法处理浮动垃圾。在并发清除阶段，用户程序继续运行，可能产生新的内存垃圾，这一部分垃圾出现在标记过程之后，因此，CMS无q k Y法清除。这部分垃圾称为“浮动垃圾“
C、需要预留一部分内存，在垃圾回收时，给用户程序使用。
D、基于标记-清除算法，8 L - G容易产生大量内存碎片，导致full GC（full GC进行内存碎片的整理）
6、 对象头部分的内存布局：HotSpot的对象头分为两部分，第一部分用于存储对象自身的运行时数o $ w 0 # v据，比如哈希码、GC分代年龄等。另外一部分用于指向方法区对象类型数据的指针。
7、 偏向锁：偏向锁偏向于第一个获取它的线程，如果在接下来的执行过程，没有其他线程获取该锁，则持有偏向锁Q R O 7 x 8 (的线程永远不需要同步。
（当一个线W w | ~ e程获取偏向锁，它每次进入这个锁相关的同步块，虚拟机不再进行任何同步操作c k .。当有另外一个线程尝试获取这个锁时，偏向模式宣告结束）
JVM优化：
1、一般来说，当survivor区不够大D  = f c C /或者占用量达D ~ L K = 8 H a H到50%，就会把一些对象放到老年区。通过设置合理的eden区，survivor区及使用率，可以将年轻对象保存在. | Y f I年轻代，从而避免full GC，使用-Xmn设置年轻代的大小
2、对于占用内存比较多的大对象，一般会选择在老年代分配内存。如果在年轻代给大对象分配内存，年轻代内存不够了，就要在eden区移动大量对象到老年代，然后这些移动的对象可能很快消亡，因此导致full GC。通过设置参数：-XX:PetenureSizeThreshold=1000000，单位为B，标明对象大小超过1M时，在老年代(tenured)分配内存? U b K空9 @ _间。
3、一般情况下，年轻对象放在eden区，当第一次GC后，如果对象还存活，放到survivor区，此后，每GC一Z 2 h S (次，年龄增加1，当对象的年龄达到阈值，就被放到tenured0 x e M t : f y老年区。
这个阈值可以同构-XX:MaxTenurin B = B FngThreshold设置。如果想让对象留在年轻代，可以设置y l F a t u z !比较大的阈值。
4、设置最小堆和最大堆：-Xmx和-Xms稳定的堆大小堆垃圾回收是有利的，获得一个稳定的堆大小的方法是设置-Xms和-Xmx的值一样，即最大堆和最小堆一样，如果这样子设置，系统在运行时堆大小理论上是恒定的，稳定的堆空间可以减少GC次数，因此，很多服务端都会将这两个参数设置为一样的数值。稳定的堆大小虽然减少GC次数，但是增加每次GC的时间，因为每次GC要把堆的大L ^ R 4 k q 6 J小维持在一个区间内。
5、一个不稳定的堆并非毫无用处。在系统不需要使用大内存的时候，压缩堆空间，使得GC每次应对一个较小的堆空间，加快单次GC次数。基于这种考虑，JVM提供两个参数，用于压缩和扩: c X : p E T T $展堆空间。
（1）-XX:MinHeapFrer 0 r TeRatio 参数用于设置堆空间的最小空闲比率。默认值是40，当堆空8 j ^间的空闲内存比率小于40，JVM便会扩展堆空h o - D P 5 d间
（2）-XX:MaxHeapFref u j = v weRatio 参数用于设置堆空间的最大3 F - T m t f u 0空闲比率。默认值是70， v o l  当堆空间的空闲内存比率大于70，JVM便会压缩堆空间。
（3）当-Xmx和-Xmx相等时，上面两个参数无效
6、通过增大吞吐量提高系统性能，可以通过设置并行垃圾回收收集器。
（1）-XXL V U / c x } Z 9:+UseParallelGC:年轻代使+ C Q D用并行垃圾回收收集器。这是一个关注吞吐量的收集器，可以尽可能的减少垃圾回收时间。
（2）-XX:+UseParallelOldGC:设置老年代使用并行垃圾回收收集器。
7、尝试使用大的内存分页：
使用大的内存分页增加CPU的内存寻址能力，@ , S m从而系统的性能。
-XX:+LargePageSizeInBytes 设置内存页的大小
8、使用非占用的垃圾收集器。
-XX:+UseConcMarkSweepGC老年代使用CMS收集器降低停顿。
9、-XXSurvivorRatio=3，表示年轻代中的分配比率：survivor:eden = 2:3
10、JVM性能调优的工具：
（1）jps（Java Process Status）：输出JVM中运行的进程状态信息(现在一般使用jconA $  I B O r ]sole)
（2t ; M H : ^ K）jstack：查看java进程内线程的堆栈信息。
（3）jmap：用于6 p b U生成堆转存快照
（4）jhat：用于分析jmap生成的堆转存快照（一般不推荐使用，而是使用Ecplise MM C x Q U 4 8emory AnalyzG @ G d , Q $ 1er）
（3）jstat是JVM统计监测工具。可以用来显示垃圾回收信息、类加载信息、新生代统计信息等。
（4）VisualVM：故障处理工具

类加载机制：
一、 概念：类加载器把class文件中的二进制数据读入到内存中，存放在方法区，然后在堆区创建一个java.la# u R 9 z  Qng.Class对象，用来封装~ ) E @ N v类在方法区内的数据结构。类加载R 6 K _ 9 p = = g的步骤如下：
1、加载：查找并加载类的二进制数据（把class文件里面的信息加载到内存里面）
2、连接：把内存中类的二进制数据合并到虚拟机的运行时环境中
（1）验证：确保被加载的类的正确性。包括：
   A、类文件的结构检查：检查是否满e X { V U + ^ E t足Java类文件的固定格式
   B、语义检查：确保类本身符合Java的语法规范
   C、字节码验证：m ? a h : *确保字节码流可以被Java虚拟机安全的执行。
   字节码流是操作码组成& S b的序列。每一个操M / e M作码后面都会跟着一个或者多个操作数。
   字节码检查这个步骤会检查每一个操R Q T G Z作码是否合法。
   D、二进制兼容性验证 g方法区中的内存位置）
3、初始化：为类的静态变量赋予正确的初始值。当静态变量的等号右M f  f 9边的值是一个常量表达式时，不会调用stat) s Y % ( hic代码块进y ! J } ] A T行初始化。只有等号右边的值是一个运行时运算出来的值，才会调用static初始化。
二、双亲委派模型：
1、当一个类加载器收到类加载请求的时% k n ? F i =候，它首先不会自己? ` _ k去加载这个类的信息，而是把该请求转发给父类加载器，依次向上。所以所有的类加载请求都会被传递到父类加载器中，只有当父类加载器中无法加S Y ] ^ =载到所需的类，子类加载器才会自己尝试去加载该类。当当前类加载器和所有父类加载器都无法加载该类时，抛出ClassNotK Z Y 7 m ~ qFindException异常。
2、意义：
提高系统的安全性。用户自定义的类加载器不可能加载应该由父加1 b j B ( 9 始类加载器：定义类加载器及其所Z l L m 有子加载器都称作初始类加载器。
5、运行时包：
（1）由同一个类加载器加载并且拥有相同包名的类组成运行时包
（2S ) P）只有属于同一个运行时包的类，才能访问包可见（default）的类和类成员。作? S W用是 限制用户自定义的类冒充核心类库的类去访问核心类库的包可见成员。
6、加载) ) E G $ @ :两份相同的clZ ` ) 7 F  b ~ Jass对象的情况：~ M z J L u *A和B不属于父子类加载器关系，并且各自都加载了同I C e i & A一个类。
三、特点：
1、全盘负责：当一个类加载器加载一个类时，该类所依赖的其他类也会被这个类加1 l 0 - =载器加载到内存中。
2、缓存机制：所有的Class对象都会被缓存，当程序需要使用某个Class时，类加载器先从缓存中查找，找不到1 F  * H h C，才从class文件中读取数据，转化成Class对象，存入缓存中。
三、 类加载器：两种a ? p b h , :类型的类加载器：
1、 JVM自带的类加载器（3种）：
（1）根类加载器（Bootstrap）：a、C++编写的，程序员无法在程序中获取该类b、负责加载虚拟机的核心库，比如java.laj @ $ E + } k 5 ^ng.Objectc、没有继承ClassLoader类。
（2）扩展类加载器（Extension）：
a、Java编写的，从指定目录中加载类库；
b、父加载器是根类加载器；
c、是ClassLoade{ ; 6 Tr的子类；
d、如果用户把创建的) M j Sj; - O : S @ iar文件放到指定目录中，也会被扩展加载器加载。
（3）系统加载器（System）或者应用加载器(App)：
a、Java编写的；
b、父加~ U _ t载器是扩展类加载器；
c、从环境变量或者class.path中加载类；
d、是: K @ &用户自定义类加载的默认父加载器；
e、是Clas) f ^ #sLoaq t d n & 9 3 Oder的子类
2、用户自定义4 ; I y F T的类加载器：
（1）Java.lang.ClassLoade^ + or类的子类；
（2）用户可以定制类的加载方式；
（3）父类加载器O P 2 / e ^ ; m e是系统加载器；
（4）编写步骤：
A、继承CH U J u p @ 0 , 9lassLoader；
B、重写findClass方法。从特定位置加载class文件，得到字节数组，然后利用defineClass把字节数组转化为Class对象
（5）为什么要自定义类加载器？
A、可以从指定位置加载class文件，比如说从数据库、云端加载class文件；
B、加密：Java代码可以被轻易的反编译，因此，如s 6 2 ?果需要对代码进行加密，那么加密以后的代码- | i , % 始化。
3、 JVM规范允许类加载器在预料某个类将要被使用的时候，就预先加载它。如果该class文件缺失或者存在错误，则在程序“首次 主动使用”的时候，才报告这个错误。（Linka7 a Tge Error错误）。如果这个类一直没有被程序“主动使用”，就不会报错。
类加载机制与接口：
1、 当Java虚拟机初始化一个类时，不会初始化该类实现的接口。
2、 在初始化一个接口时，不会初始化这个接口父接口。
3、 只有当程序首次使用该接口的静态变量时，才导致该接口的初始化。
ClassLoader：1、 调用Classloader的a [ z G  - ^ |loadClass方法去加载一个类，不是主动使用，因此不会进行类的初始化。
类的卸载：1、 有JVM自带的三种类加载器（根、扩展、系统）加载的类始终不会卸载。因为JVM始终引用这些类加载E Y ; w K器2 Z - f Q l z ? g，这些类加载器使用引用他们所加载的类，因此这些Class类对象始终是可到达的。2、 由用户自定义类加载器4 L 9 ( F ; 加载的类，是可以被卸载的。
补充：
Jn t 2DK和JRK
（1）JD0 A xK ： Java Development Kit，开发的时候用到的类包。（2）JRE ： Java Runtime Environment，Java运行的基础，包含运行时需要的所有类库。
图解java文件转化成机器码
JVM虚拟机先将java文件编译成class文件（字节} c y s ( v码文件），然后再将class文件转换成所有操作系统都能运行的机器指令。

好了，记得认真学习一下——收藏一把，可以随时再阅；分享出去，大家一起学习，再顺手来个点赞！