堆针对一个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 ) ; }
}
永久区 Young Generation Space：新生区（Young/New ），又被划分为Eden区和Survivor区 元空间 Young Generation Space：新生区（Young/New ），又被划分为Eden区和Survivor区 > 新生代 < > 年轻代 、养老区 <> 老年区 < > 老年代、永久区 <==> 永久代
永久代替换成元空间
-Xms用于表示堆区的初始内存，等价于-XX:InitialHeapSize -Xmx所指定的最大内存时，将会抛出OutOfMemoryError异常。-Xms和-Xmx两个参数配置相同的值，其目的是为了能够在垃圾回收机制清理完堆区后不需要重新分割计算堆区的大小，从而提高性能。
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日志
最终会导致内存溢出。 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。 循环过多或死循环，产生大量对象。 单例模式，和静态集合导致内存泄漏的原因类似，因为单例的静态特性，它的生命周期和JVM的生命周期一样长，所以如果单例对象如果持有外部对象的引用，那么这个外部对象也不会被回收，那么就会造成内存泄漏。 资源性对象在不使用的时候，应该调用它的close()函数将其关闭掉。
内存中加载的数据量过于庞大，如一次从数据库取出过多数据。 代码中存在死循环或循环产生过多重复的对象实体。 修改JVM启动参数，增加内存。（-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的时候，就会将该对象放到老年代。
new的对象先放Eden区。此区有大小限制。 然后将伊甸园中的剩余对象移动到幸存者0区。 如果再次经历垃圾回收，此时会重新放回幸存者0区，接着再去幸存者1区。 在养老区，相对悠闲。当养老区内存不足时，再次触发GC：Major GC，进行养老区的内存清理
谁为空就为To区，每次GC的时候，Eden区中的对象永远先往To区放。
注意：在Eden区满了的时候，才会触发YGC/Minor GC操作，而幸存者区满了之后，不会触发GC操作；当Eden区满了的触发YGC操作的时候，会将Eden区和Surviver区一起进行回收，Surviver被动回收。
如果Eden执行了YGC还是无法放不下该对象，那没得办法，只能说明是超大对象，直接方法放老年代
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区放。
1、先下载Jprofiler工具进行安装，阿里网盘下载地址链接
Minor GC、Major GC、Full GC说明： Minor GC：只清除新生代的垃圾 垃圾收集，需要尽量的避免垃圾回收，因为在垃圾回收的过程中，容易出现STW（Stop the World）的问题，而Major GC和Full GC出现STW的时间，是Minor GC的10倍以上部分收集：不是完整收集整个Java堆的垃圾收集，还有如下分类： 新生代收集（Minor GC / Young GC）：只是新生代（Eden、S0、S1）的垃圾收集。 整堆收集：收集整个Java堆和方法区的垃圾收集。
当年轻代空间不足时，就会触发Minor GC，这里的年轻代满指的是Eden区满，Survivor区满不会触发GC操作，每次Minor GC会清理年轻代的内存。
指的是发生在老年代的GC，对象从老年代消失时，Major GC或Full GC发生了。 也就是说在老年代空间不足时，会先尝试触发Minor GC。如果之后空间还是不足，则触发Major GC。
调用System.gc()时，系统建议执行Full 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 Kclass space used 352 K, capacity 388 K, committed 512 K, reserved 1048576 K
Exception in thread "main" java. lang. OutOfMemoryError: Java heap spaceat 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%的对象是临时对象。 新生代：有Eden、两块大小相同的Survivor（又称为from/to，s0/s1）构成，To总为空。 优化GC性能 如果没有分代，那所有的对象都在一块，就如同把一个学校的人都关在一个教室。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空间内。快速分配策略。
说明： 尽管不是所有的对象实例都能够在TLAB中成功分配内存，但JVM确实是将TLAB作为内存分配的首选。 默认情况下，TLAB空间的内存非常小，仅占有整个Eden空间的1%，可以通过-XX:TLABWasteTargetPercent来设置TLAB空间所占用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字符串缓存和静态变量并不是被转移到元数据区，而是直接在堆上分配，所以这一点同样符合前面一点的结论：对象实例都是分配在堆上。
具体查看某个参数的指令：jps查看当前运行中的进程
检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。 如果大于，则此次Minor GC是安全的。（因为最坏的情况，新生代的所有对象都不需要回收，且它们都达到了晋升老年代的要求，此时将它们都放入到老年代，老年代的内存足够存放它们） HandlePromotionFailure=true，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小。若大于，则尝试进行一次Minor GC，但这次Minor GC依然是有风险的；若小于或HandlePromotionFailure=false，则进行一次Full GC。 在JDK6 Update 24（JDK7）之后，HandlePromotionFailure参数不会再影响到虚拟机的空间分配担保策略，观察OpenJDK中的源码变化，虽然源码中还定义了HandlePromotionFailure参数，但是在代码中已经不会再使用它。
普通的对象可能会被分配在TLAB上；Minor GC的发生频率要比Major GC高很多，即老年代中垃圾回收发生的频率将大大低于年轻代。 (因为new的对象一般都分配在新生代, 新生代的对象都是朝生夕死的, 所以GC得频率很高) 
