堆针对一个JVM进程来说是唯一的，也就是一个进程只有一个JVM，但是进程包含多个线程，他们是共享同一堆空间的。
物理上不连续的内存空间中，但在逻辑上它应该被视为连续的。
public class HeapTest1 {
public static void main ( String [ ] args) {
System . out. println ( "start..." ) ;
try {
Thread . sleep ( 1000000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
System . out. println ( "end..." ) ;
}
}
public class HeapTest2 {
public static void main ( String [ ] args) {
System . out. println ( "start..." ) ;
try {
Thread . sleep ( 1000000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
System . out. println ( "end..." ) ;
}
}
设置最小堆内存：-Xms10m设置最大堆内存：-Xmx10mjvisualvm
所有的对象实例以及数组都应当在运行时分配在堆上。（The heap is the run-time data area from which memory for all class instances and arrays is allocated）
public class SimpleHeap {
private int id;
public SimpleHeap ( int id) {
this . id = id;
}
public static void main ( String [ ] args) {
SimpleHeap s1 = new SimpleHeap ( 1 ) ;
SimpleHeap s2 = new SimpleHeap ( 2 ) ;
}
}
永久区 元空间 > 新生代 < > 年轻代 、养老区 <> 老年区 < > 老年代、永久区 <==> 永久代
永久代替换成元空间
-Xms用于表示堆区的初始内存，等价于-XX:InitialHeapSize -Xmx用于表示堆区的最大内存，等价于-XX:MaxHeapSize -Xmx所指定的最大内存时，将会抛出OutOfMemoryError异常。-Xms和-Xmx两个参数配置相同的值，其目的是为了能够在垃圾回收机制清理完堆区后不需要重新分割计算堆区的大小，从而提高性能。 物理电脑内存大小/64 物理电脑内存大小/4
public class HeapSpaceInitial {
public static void main ( String [ ] args) {
long initialMemory = Runtime . getRuntime ( ) . totalMemory ( ) / 1024 / 1024 ;
long maxMemory = Runtime . getRuntime ( ) . maxMemory ( ) / 1024 / 1024 ;
System . out. println ( "-Xms：" + initialMemory + "M" ) ;
System . out. println ( "-Xmx：" + maxMemory + "M" ) ;
}
}
- Xms ：243 M
- Xmx ：3591 M
jps命令查看当前所有Java进程pid
jstat -gc pid查看jvm的GC情况
参数 说明 S0C、S1C、S0U、S1U 第一、第二个幸存区的大小和使用量 EC、EU Eden区容量和使用量 OC、OU 老年代大小和使用量 MC、MU 方法区大小和使用量 CCSC、CCSU 压缩类空间大小和使用量 YGC、YGCT 年轻代垃圾回收次数和消耗时间 FGC、FGCT 老年代垃圾回收次数和消耗时间 GCT 垃圾回收消耗总时间
-XX:+PrintGCDetails启动参数显示GC日志
最终会导致内存溢出。 close掉），否则不会被GC回收。 close()函数将其关闭掉。
-Xms与-Xmx参数）
public class OOMTest {
public static void main ( String [ ] args) {
List < People > = new ArrayList < > ( ) ;
while ( true ) {
try {
Thread . sleep ( 20 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
list. add ( new People ( new Random ( ) . nextInt ( 1024 * 1024 ) ) ) ;
}
}
}
class People {
private byte [ ] arr;
public People ( int length) {
this . arr = new byte [ length] ;
}
}
-Xms600m -Xmx600m，运行程序后，就出现OOM了
Eden : From : To = 8 : 1 : 1新生代 : 老年代 = 1 : 2-Xmn60M：设置新生代分配的空间大小（包括一个Eden和两个Survivor），一般不设置。
-XX:NewRatio=2，表示新生代占1，老年代占2，新生代占整个堆的1/3-XX:NewRatio=4，表示新生代占1，老年代占4，新生代占整个堆的1/5注意：当发现在整个项目中，生命周期长的对象偏多，那么就可以通过调整老年代的大小，来进行调优
-XX:SurvivorRatio调整这个空间比例。默认-XX:SurvivorRatio=8，也就是说Eden占新生代的8/10几乎所有的Java对象都是在Eden区被new出来的。绝大部分的Java对象的销毁都在新生代进行。（有些大的对象在Eden区无法存储时候，将直接进入老年代）
−
X
m
n
大小
∗
(
−
X
X
:
S
u
r
v
i
v
o
r
R
a
t
i
o
大小
/
(
−
X
X
:
S
u
r
v
i
v
o
r
R
a
t
i
o
大小
+
1
+
1
)
)
-Xmn大小 * (-XX:SurvivorRatio大小 / (-XX:SurvivorRatio大小 + 1 + 1))
− X mn 大小 ∗ ( − XX : S u r v i v or R a t i o 大小 / ( − XX : S u r v i v or R a t i o 大小 + 1 + 1 ))
new的对象，会先放到Eden区，如果Eden满了，此时会进行MinorGC对Eden进行垃圾回收，将没有引用的对象释放掉，幸存下来的对象，会被移动到幸存者0（Survivor0）区；当再次发生MinorGC的时候，也会顺带对幸存者区进行回收，此时MinorGC后，会将伊甸园区的存活对象放到幸存者1区，幸存者0区原来存活的对象仍然存活，此时也将它们移动到幸存者1（Survivor1）区。此时对象的年龄计数器(+1)；以此类推，当在对象的年龄计数器到15的时候，就会将该对象放到老年代。
-XX:MaxTenuringThreshold=N进行设置。
谁为空就为To区，每次GC的时候，Eden区中的对象永远先往To区放。
注意：在Eden区满了的时候，才会触发YGC/Minor GC操作，而幸存者区满了之后，不会触发GC操作；当Eden区满了的触发YGC操作的时候，会将Eden区和Surviver区一起进行回收，Surviver被动回收。
public class HeapInstanceTest {
byte [ ] arr = new byte [ new Random ( ) . nextInt ( 1024 * 1024 ) ] ;
public static void main ( String [ ] args) throws InterruptedException {
ArrayList < HeapInstanceTest > = new ArrayList < > ( ) ;
while ( true ) {
list. add ( new HeapInstanceTest ( ) ) ;
Thread . sleep ( 25 ) ;
}
}
}
-Xms600m -Xmx600m，运行程序，打开jvisualvm通过VisualGC进行动态化查看，最终在老年代和新生代都满了，就出现了OOM
标记-复制算法，它们直接有交换，谁为空就为To区，每次GC的时候，Eden区中的对象永远先往To区放。
阿里网盘下载地址链接
Minor GC、Major GC、Full GC说明： 垃圾收集，需要尽量的避免垃圾回收，因为在垃圾回收的过程中，容易出现STW（Stop the World）的问题，而Major GC和Full GC出现STW的时间，是Minor GC的10倍以上部分收集：不是完整收集整个Java堆的垃圾收集，还有如下分类： 注意：很多时候Major GC会和Full GC混淆使用，需要具体分辨是老年代回收还是整堆回收。 整堆收集：收集整个Java堆和方法区的垃圾收集。
Java对象大多数都具备朝生夕死的特性，所以Minor GC会很频繁，一般回收速度也比较快。
Full GC是开发或调优中尽量要避免的，这样暂时时间会短一些。
public class GCTest {
public static void main ( String [ ] args) {
int i = 0 ;
try {
List < String > = new ArrayList < > ( ) ;
String s = "itan" ;
while ( true ) {
list. add ( s) ;
s = s + s;
i ++ ;
}
} catch ( Exception e) {
e. printStackTrace ( ) ;
System . out. println ( "遍历次数为：" + i) ;
}
}
}
在OOM之前，一定会触发一次Full GC，因为只有在老年代空间不足时候，才会爆出OOM异常。
[ GC ( Allocation Failure ) [ PSYoungGen : 2044 K-> 504K ( 2560 K) ] 2044 K-> 944K ( 9728 K) , 0.0019037 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.00 secs]
[ GC ( Allocation Failure ) [ PSYoungGen : 2100 K-> 504K ( 2560 K) ] 2540 K-> 1860K ( 9728 K) , 0.0014735 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.00 secs]
[ Full GC ( Ergonomics ) [ PSYoungGen : 1693 K-> 0K ( 2560 K) ] [ ParOldGen : 6476 K-> 4690K ( 7168 K) ] 8169 K-> 4690K ( 9728 K) , [ Metaspace : 3192 K-> 3192K ( 1056768 K) ] , 0.0056784 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.01 secs]
[ GC ( Allocation Failure ) [ PSYoungGen : 115 K-> 160K ( 2560 K) ] 6853 K-> 6898K ( 9728 K) , 0.0007642 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.00 secs]
[ Full GC ( Ergonomics ) [ PSYoungGen : 160 K-> 0K ( 2560 K) ] [ ParOldGen : 6738 K-> 4714K ( 7168 K) ] 6898 K-> 4714K ( 9728 K) , [ Metaspace : 3206 K-> 3206K ( 1056768 K) ] , 0.0048462 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.00 secs]
[ GC ( Allocation Failure ) [ PSYoungGen : 39 K-> 0K ( 2560 K) ] 6802 K-> 6762K ( 9728 K) , 0.0005407 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.00 secs]
[ Full GC ( Ergonomics ) [ PSYoungGen : 0 K-> 0K ( 2560 K) ] [ ParOldGen : 6762 K-> 6762K ( 7168 K) ] 6762 K-> 6762K ( 9728 K) , [ Metaspace : 3206 K-> 3206K ( 1056768 K) ] , 0.0067033 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.01 secs]
[ GC ( Allocation Failure ) [ PSYoungGen : 0 K-> 0K ( 2560 K) ] 6762 K-> 6762K ( 9728 K) , 0.0005572 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.00 secs]
[ Full GC ( Allocation Failure ) [ PSYoungGen : 0 K-> 0K ( 2560 K) ] [ ParOldGen : 6762 K-> 6744K ( 7168 K) ] 6762 K-> 6744K ( 9728 K) , [ Metaspace : 3206 K-> 3206K ( 1056768 K) ] , 0.0075936 secs] [ Times : user= 0.06 sys= 0.00 , real= 0.01 secs]
Heap
PSYoungGen total 2560 K, used 60 K [ 0x00000000ffd00000 , 0x0000000100000000 , 0x0000000100000000 )
eden space 2048 K, 2 % used [ 0x00000000ffd00000 , 0x00000000ffd0f288 , 0x00000000fff00000 )
from space 512 K, 0 % used [ 0x00000000fff00000 , 0x00000000fff00000 , 0x00000000fff80000 )
to space 512 K, 0 % used [ 0x00000000fff80000 , 0x00000000fff80000 , 0x0000000100000000 )
ParOldGen total 7168 K, used 6744 K [ 0x00000000ff600000 , 0x00000000ffd00000 , 0x00000000ffd00000 )
object space 7168 K, 94 % used [ 0x00000000ff600000 , 0x00000000ffc96230 , 0x00000000ffd00000 )
Metaspace used 3238 K, capacity 4496 K, committed 4864 K, reserved 1056768 K
class space used 352 K, capacity 388 K, committed 512 K, reserved 1048576 K
Exception in thread "main" java. lang. OutOfMemoryError: Java heap space
at java. util. Arrays. copyOf ( Arrays . java: 3332 )
at java. lang. AbstractStringBuilder. ensureCapacityInternal ( AbstractStringBuilder . java: 124 )
at java. lang. AbstractStringBuilder. append ( AbstractStringBuilder . java: 448 )
at java. lang. StringBuilder. append ( StringBuilder . java: 136 )
at day3. GCTest. main ( GCTest . java: 20 )
[ Full GC ( Ergonomics ) [ PSYoungGen : 1693 K-> 0K ( 2560 K) ] [ ParOldGen : 6476 K-> 4690K ( 7168 K) ] 8169 K-> 4690K ( 9728 K) , [ Metaspace : 3192 K-> 3192K ( 1056768 K) ] , 0.0056784 secs] [ Times : user= 0.00 sys= 0.00 , real= 0.01 secs]
PSYoungGen: 1693K->0K(2560K)]：年轻代总空间大小为2560k，回收前内存占用1693k，经过垃圾回收后内存占用Ok。ParOldGen: 6476K->4690K(7168K)]：老年代总空间为7168k，回收前内存占用6476k，经过垃圾回收后内存占用4690k。堆空间总大小为9728k，当前占用8169k，经过垃圾回收后内存占用4690k。Metaspace: 3192K->3192K(1056768K)]：元空间总空间为1056768K，当前占用3192k，经过垃圾回收后剩余3192k
伊甸园区，新生代的对象，一般生命周期都很短。此时将堆分为年轻代和老年代。对存放生命周期短的年轻代进行GC即可。70%-99%的对象是临时对象。 优化GC性能
-XX:MaxTenuringThreshold来设置
-XX:HandlePromotionFailure，也就是经过Minor GC后，所有的对象都存活，因为Survivor比较小，所以就需要将Survivor无法容纳的对象，存放到老年代中。
public class BugObject {
public static void main ( String [ ] args) {
byte [ ] b = new byte [ 1024 * 1024 * 20 ] ;
}
}
每个线程分配了一个私有缓存区域，它包含在Eden空间内。快速分配策略。
说明： JVM确实是将TLAB作为内存分配的首选。 -XX:UseTLAB参数来设置是否开启TLAB空间。 仅占有整个Eden空间的1%，可以通过-XX:TLABWasteTargetPercent来设置TLAB空间所占用Eden空间的百分比大小。 使用加锁机制确保数据操作的原子性，从而直接在Eden空间中分配内存。
public class TLABTest {
public static void main ( String [ ] args) throws InterruptedException {
System . out. println ( "测试TLAB" ) ;
Thread . sleep ( 20000 ) ;
}
}
在一个方法里产生并销毁的对象，该对象不会通过参数，返回值传递到方法外）逃逸分析的缺点，而且我们主流的Hotspot JVM明确说明不使用逃逸分析这项技术；所以说堆上分配是对象的唯一选择！逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐变得不那么“绝对”了。如果经过逃逸分析（Escape Analysis）后发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配。这样就无需在堆上分配内存，也无须进行垃圾回收了。这也是最常见的堆外存储技术。
1、没有发生逃逸的对象，则可以分配到栈上，随着方法执行的结束，栈空间就被移除。
public void method1 ( ) {
V v = new V ( ) ;
v = null ;
}
(因为sb对象, 通过方法返回给了方法调用者)
public static StringBuffer createStringBuffer ( String s1, String s2) {
StringBuffer sb = new StringBuffer ( ) ;
sb. append ( s1) ;
sb. append ( s2) ;
return sb;
}
public static String createStringBuffer ( String s1, String s2) {
StringBuffer sb = new StringBuffer ( ) ;
sb. append ( s1) ;
sb. append ( s2) ;
return sb. toString ( ) ;
}
public class EscapeAnalysis {
public EscapeAnalysis obj;
public EscapeAnalysis getInstance ( ) {
return obj == null ? new EscapeAnalysis ( ) : obj;
}
public void setObj ( ) {
this . obj = new EscapeAnalysis ( ) ;
}
public void useEscapeAnalysis ( ) {
EscapeAnalysis e = new EscapeAnalysis ( ) ;
}
public void useEscapeAnalysis2 ( ) {
EscapeAnalysis e = getInstance ( ) ;
}
}
-XX:+DoEscapeAnalysis显式开启逃逸分析。通过-XX:+PrintEscapeAnalysis查看逃逸分析的筛选结果。能使用局部变量的，就不要使用在方法外定义。(因为成员变量，会导致多线程访问该变量，造成该变量的线程不安全。如果是局部变量，首先局部变量存储在虚拟机栈中，是线程私有的，所以不会造成安全问题)。
栈上分配：将堆分配转化为栈分配。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会发生逃逸，对象可能是栈上分配的候选，而不是堆上分配。同步省略：如果一个对象被发现只有一个线程被访问到，那么对于这个对象的操作可以不考虑同步。分离对象或标量替换：有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。
public class StackAllocation {
public static void main ( String [ ] args) throws InterruptedException {
long start = System . currentTimeMillis ( ) ;
for ( int i = 0 ; i < 100000000 ; i++ ) {
alloc ( ) ;
}
long end = System . currentTimeMillis ( ) ;
System . out. println ( "花费的时间为：" + ( end - start) + " ms" ) ;
Thread . sleep ( 10000000 ) ;
}
private static void alloc ( ) {
User user = new User ( ) ;
}
}
class User {
private String name;
private String age;
private String gender;
private String phone;
}
-Xmx1G -Xms1G -XX:-DoEscapeAnalysis -XX:+PrintGCDetails
-Xmx1G -Xms1G -XX:+DoEscapeAnalysis -XX:+PrintGCDetails
判断同步块所使用的锁对象是否只能够被一个线程访问而没有被发布到其他线程。如果没有，那么JIT编译器在编译这个同步块的时候就会取消对这部分代码的同步。这样就能大大提高并发性和性能。这个取消同步的过程就叫同步省略，也叫锁消除。
public class SynchronizedTest {
public void method ( ) {
Object obj = new Object ( ) ;
synchronized ( obj) {
System . out. println ( obj) ;
}
}
}
public class SynchronizedTest {
public void method ( ) {
Object obj = new Object ( ) ;
System . out. println ( obj) ;
}
}
同步省略操作是在解释运行时发生的
标量（Scalar）是指一个无法再分解成更小的数据的数据。Java中的原始数据类型就是标量。聚合量（Aggregate），Java中的对象就是聚合量，因为他可以分解成其他聚合量和标量。标量替换。
public static void main ( String args[ ] ) {
alloc ( ) ;
}
class Point {
private int x;
private int y;
}
private static void alloc ( ) {
Point point = new Point ( 1 , 2 ) ;
System . out. println ( "point.x" + point. x + ";point.y" + point. y) ;
}
private static void alloc ( ) {
int x = 1 ;
int y = 2 ;
System . out. println ( "point.x = " + x + "; point.y=" + y) ;
}
Point这个聚合量经过逃逸分析后，发现他并没有逃逸，就被替换成两个聚合量了。就是可以大大减少堆内存的占用。因为一旦不需要创建对象了，那么就不再需要分配堆内存了。-XX:+ElimilnateAllocations开启了标量替换（默认打开），允许将对象打散分配在栈上。
public class ScalarReplace {
public static class User {
public int id;
public String name;
}
public static void alloc ( ) {
User u = new User ( ) ;
u. id = 5 ;
u. name = "itan" ;
}
public static void main ( String [ ] args) {
long start = System . currentTimeMillis ( ) ;
for ( int i = 0 ; i < 10000000 ; i++ ) {
alloc ( ) ;
}
long end = System . currentTimeMillis ( ) ;
System . out. println ( "花费的时间为： " + ( end - start) + " ms" ) ;
}
}
-Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-EliminateAllocations
-Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:+EliminateAllocations
无法保证逃逸分析的性能消耗一定能高于他的消耗。虽然经过逃逸分析可以做标量替换、栈上分配、和锁消除。但是逃逸分析自身也是需要进行一系列复杂的分析的，这其实也是一个相对耗时的过程。即时编译器优化技术中一个十分重要的手段。intern字符串的缓存和静态变量曾经都被分配在永久代上，而永久代已经被元数据区取代。但是，intern字符串缓存和静态变量并不是被转移到元数据区，而是直接在堆上分配，所以这一点同样符合前面一点的结论：对象实例都是分配在堆上。
检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。 -XX:HandlePromotionFailure设置值是否允担保失败。 HandlePromotionFailure=true，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小。若大于，则尝试进行一次Minor GC，但这次Minor GC依然是有风险的；若小于或HandlePromotionFailure=false，则进行一次Full GC。 只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC，否则将进行Full GC。
普通的对象可能会被分配在TLAB上；Minor GC的发生频率要比Major GC高很多，即老年代中垃圾回收发生的频率将大大低于年轻代。 (因为new的对象一般都分配在新生代, 新生代的对象都是朝生夕死的, 所以GC得频率很高)
2263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
