Java 虚拟机内存模型
JVM 虚拟机将其内存数据分为程序计数器、虚拟机栈、本地方法栈、Java 堆和方法区等部分。
程序计数器用于存放下一条运行的指令；虚拟机栈和本地方法栈用于存放函数调用栈信息； Java堆用于存放Java 程序运行时所需的对象等数据；方法区用于存放程序的类元数据信息。
程序计数器- Program Counter Register
是一块很小内存空间。 由于Java 是支持线程的语言， 当线程数量超过CPU 数量时，线程之间根据时间片轮询抢夺CPU 资源。对于单核CPU 而言， 每一时刻，只能有一个线程在运行，而其他线程必须被切换出去。为此，每一个线程都必须用一个独立的程序计数器， 用于记录下一条要运行的指令。各个线程之间的计数器互不影响，独立工作；是一块线程私有的内存空间。
如果当前线程正在执行一个Java 方法，则程序计数器记录正在执行的Java 字节码地址，如果当前线程正在执行一个Native 方法， 则程序计数器为空。Java 虚拟机栈
Java 虚拟机栈也是线程私有的内存空间， 它和Java 线程在同一时间创建， 它保存方法的局部变量、部分结果，并参与方法的调用和返回。
Java虚拟机规范允许Java 栈的大小是动态的或是固定的。在Java 虚拟机规范中，定义了两种异常与栈空间有关： StackOverflowError 和OutOfMemoryError.
如果线程在计算过程中， 请求的栈深度大于最大可用的栈深度，则抛出StackOverflowError;
如果Java 栈可以动态扩展，而在扩展栈的过程中， 没有足够的内存空间来支持栈的扩展，则抛出OutOfMemoryError.
在HotSpot 虚拟机中， 可以使用-Xss参数来设置栈的大小。
看一段代码：
TestStack.java
package com.oscar999.performance.JVMTune;
import org.junit.Test;
public class TestStack {
private int count = 0;
public void recursion(){
count ++;
recursion();
}
@Test
public void testStatck(){
try{
recursion();
}catch(Throwable e){
System.out.println("deep of stack is "+count);
e.printStackTrace();
}
}
}
运行结果
如果调整stack space 的大小， 在eclipse中， 如下设置
运行结果：
深度增加了不少。
虚拟机栈在运行时使用一种叫做栈帧的数据结构保存上下文数据。在栈帧中，存放了方法的局部变量表、操作数栈、动态连接方法和返回地址等信息。
每一个方法的调用都伴随着栈帧的入栈操作， 相应地，方法的返回则表示栈帧的出栈操作。如果方法调用时，方法的参数和局部变量相对较多，那么栈帧中的局部变量就会比较大，栈帧会膨胀以满足方法调用所需传递的信息， 因此， 单个方法调用所需的栈空间大小也会比较多。
栈帧的结果如下：
使用jclasslib 工具可以查看class文件中每个方法所分配的最大局部变量表的容量。
可以到 http://sourceforge.NET/projects/jclasslib/files/jclasslib 中下载
可以使用jclasslib 查看一下以下类的class文件所需要的字
package com.oscar999.performance.JVMTune;
public class TestWordReuse {
public void test1() {
{
long a = 0;
}
long b = 0;
}
public void test2(){
long a = 0;
long b = 0;
}
}
结果一个是 3, 一个是5.
基于此， 看一下系统GC 回收的例子：
package com.oscar999.performance.JVMTune;
public class SystemGC {
/**
* GC 无法回收b, 因为b 还在局部变量中
*/
public static void test1() {
{
byte[] b = new byte[6 * 1024 * 1024];
}
System.gc();
System.out.println("first explict gc over");
}
/**
* GC 无法回收, 因为 赋值为null将销毁局部变量表中的数据
*/
public static void test2() {
{
byte[] b = new byte[6 * 1024 * 1024];
b=null;
}
System.gc();
System.out.println("first explict gc over");
}
/**
* GC 可以回收, 因为变量a 复用了变量b 的字，GC根无法找到b
*/
public static void test3() {
{
byte[] b = new byte[6 * 1024 * 1024];
}
int a=0;
System.gc();
System.out.println("first explict gc over");
}
/**
* GC 无法回收, 因为变量a 复用了变量c 的字，b 仍然存在
*/
public static void test4() {
{
int c = 0;
byte[] b = new byte[6 * 1024 * 1024];
}
int a=0;
System.gc();
System.out.println("first explict gc over");
}
/**
* GC 可以回收, 因为变量a 复用了变量c 的字，变量d 复用了变量b 的字
*/
public static void test5() {
{
int c = 0;
byte[] b = new byte[6 * 1024 * 1024];
}
int a=0;
int d=0;
System.gc();
System.out.println("first explict gc over");
}
/**
*
* 总是可以回收b , 因为上层函数的栈帧已经销毁
*/
public static void main(String args[]){
test1();
System.gc();
System.out.println("second explict gc over");
}
}
本地方法栈
本地方法栈和Java 虚拟机栈的功能很相似， Java 虚拟机栈用于管理Java函数的调用，而本地方法栈用于管理本地方法的调用。 本地方法并不是用Java实现的，而是用C实现的。 在SUN 的Hot Spot虚拟机中，不区分本地方法栈和虚拟机栈。因此，和虚拟机栈一样，它也会抛出StackOverflowError 和OutOfMemoryError.-
Java 堆
Java运行时内存中最为重要的部分， 几乎所有的对象和数组都是在堆中分配空间的。Java堆分为新生代和老年代两个部分。新生代用于存放刚刚产生的对象和年轻的对象，如果对象一直没有被回收，生存得足够长，老年对象就会被移入老年代。
新生代又分为：eden(伊甸园)、survivor space0(from space), survivor space1(to space)
看一下以下代码的执行情况：
package com.oscar999.performance.JVMTune;
public class TestHeapGC {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
byte[] b1 = new byte[1024*1204/2];
byte[] b2 = new byte[1024*1204*8];
b2 = null;
b2 = new byte[1204*1204*8];
//System.gc();
}
}
使用命令行运行：
java -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=15 -Xms40M -Xmx40M -Xmn20M com.oscar999.performance.JVMTune.TestHeapGC
运行结果
把上面mark 的 System.GC 打开，再运行一下
可以看到，在Full GC之后， 新生代空间被清空，未被回收的对象全部被移入老生代。
- 方法区与堆空间类似，它也是被JVM中所有的线程共享的。方法去主要保存的信息是类的元数据。
方法区中作为重要的是类的类型信息、常量池、域信息、方法信息。
在Hot Spot 虚拟机中， 方法区也被称为永久区，是一块独立于Java堆的内存空间。虽然叫做永久区，但是在永久区的对象，同样也是可以被 GC回收的。
对永久区GC的回收，通常从两个方面进行分析： 1. GC 对永久区常量池的回收 2. 永久区对类元数据的回收。
看如下代码：
package com.oscar999.performance.JVMTune;
public class TestPermGenGC {
public void permGenGC(){
for(int i=0;i<Integer.MAX_VALUE;i++)
{
String t = String.valueOf(i).intern();
}
}
public static void main(String[] args){
TestPermGenGC test = new TestPermGenGC();
test.permGenGC();
}
}
使用如下命令行运行：
java -XX:PermSize=2M -XX:MaxPermSize=4M -XX:+PrintGCDetails com.oscar999.performance.JVMTune.TestPermGenGC
会发现一直打印如下日志：
也就是说， 每当常量池饱和时，Full GC总能顺利回收常量池数据，确保程序稳定持续运行。
再来看看类元数据的回收情况，
这里要动态生成类的实例，要用到 javassist
可以到如下地址下载：
http://www.java2s.com/Code/Jar/j/Downloadjavassistjar.htm
JavaBeanObject.java
package com.oscar999.performance.JVMTune;
public class JavaBeanObject {
private String name = "java";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
TestOneClassLoad.java
package com.oscar999.performance.JVMTune;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
public class TestOneClassLoad {
public void testOneClassLoad() throws CannotCompileException, NotFoundException, InstantiationException, IllegalAccessException {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
CtClass c = ClassPool.getDefault().makeClass("Geym"+i);
c.setSuperclass(ClassPool.getDefault().get("com.oscar999.performance.JVMTune.JavaBeanObject"));
Class clz = c.toClass();
JavaBeanObject v = (JavaBeanObject)clz.newInstance();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TestOneClassLoad test = new TestOneClassLoad();
try {
test.testOneClassLoad();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
使用如下命名运行：
java -classpath .;../lib/javassist.jar -XX:PermSize=2M -XX:MaxPermSize=4M -XX:+PrintGCDetails com.oscar999.performance.JVMTune.TestOneClassLoad
持久代溢出， Full GC在这种情况下不能回收类的元数据。
事实上，如果虚拟机确认该类的所有实例已经被回收，并且加载该类的ClassLoader已经被回收， GC就有可能回收该类型。
如果新增Class MyClassLoader
package com.oscar999.performance.JVMTune;
public class MyClassLoader extends ClassLoader {
}
TestOneClassLoad 修改成：
package com.oscar999.performance.JVMTune;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
public class TestOneClassLoad {
static MyClassLoader c1 = new MyClassLoader();
public void testOneClassLoad() throws CannotCompileException, NotFoundException, InstantiationException, IllegalAccessException {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
CtClass c = ClassPool.getDefault().makeClass("Geym"+i);
c.setSuperclass(ClassPool.getDefault().get("com.oscar999.performance.JVMTune.JavaBeanObject"));
Class clz = c.toClass(c1,null);
JavaBeanObject v = (JavaBeanObject)clz.newInstance();
if(i%10==0)
c1 = new MyClassLoader();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TestOneClassLoad test = new TestOneClassLoad();
try {
test.testOneClassLoad();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
就不会出现上面的问题了。
JVM内存分配参数
- 设置最大堆内存
使用 -Xmx 参数指定。 最大堆指的是新生代和老生代的大小之和的最大值， 它是Java 应用程序的堆上限。
看例子：
package com.oscar999.performance.JVMTune;
import java.util.Vector;
public class TestXmx {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Vector v = new Vector();
for(int i=1;i<=10;i++){
byte[] b = new byte[1024*1024];
v.add(b);
System.out.println(i+"M is allocated");
}
System.out.println("Max memory:"+Runtime.getRuntime().maxMemory()/1024/1024+"M");
}
}
使用如下命令行：
java -Xmx5M com.oscar999.performance.JVMTune.TestXmx
- 设置最小堆内存
使用JVM参数 -Xms 可以用于设置系统的最小堆空间。 也就是JVM启动时，所占据的操作系统内存大小。
Java 应用程序在运行时，首先会被分配-Xms指定的内存大小， 并尽可能尝试在这个空间内运行程序。当-Xms 指定的内存大小确实无法满足应用程序时，JVM 才会向操作系统申请更多的内存，直到内存大小达到-Xmx指定的最大内存为止。若超过-Xmx的值，则抛出OutOfMemoryError异常。
如果-Xms的数值较小，那么JVM为了保证系统尽可能地在指定内存范围内运行，就会更加频繁地进行GC操作，以释放失效的内存空间，从而， 会增加Minor GC 和 Full GC的次数， 对系统性能产生一定的影响。
package com.oscar999.performance.JVMTune;
import java.util.Vector;
public class TestXms {
public static void main(String args[]) {
Vector v = new Vector();
for (int i = 1; i <= 10; i++) {
byte[] b = new byte[1024 * 1024];
v.add(b);
if (v.size() == 3)
v.clear();
}
}
}
运行命令：
java -Xmx11M -Xms4M -verbose:gc com.oscar999.performance.JVMTune.TestXms
结果：
设置新生代
参数-Xmn 用于设置新生代的大小。 设置一个较大的新生代会减小老生代的大小，这个参数对系统性能以及GC行为有很大的影响。新生代的大小一般设置为整个堆空间的1/4 到1/3 左右。
在Hot Spot 虚拟机中， -XX:NewSize用于设置新生代的初始大小， -XX:MaxNewSize 用于设置新生代的最大值。但通常情况下，只设置-Xmn已经可以满足绝大部分应用的需要。 设置-Xmn 的效果等同与设置了相同的-XX:NewSize 和 -XX:MaxNewSize.设置持久代
持久代(方法区)不属于堆的一部分。在Hot Spot 虚拟机中， 使用-XX:MaxPermSize 可以设置持久代的最大值，使用-XX:PermSize可以设置持久代的初始大小。
持久代的大小直接决定了系统可以支持多个类定义和多少常量。对于使用CGLIB或者Javassist 等动态字节码生成工具的应用程序而言，设置合理的持久代大小有助于维持系统稳定。-
设置线程栈
线程栈是线程的一块私有空间。
在JVM中， 可以使用 -Xss参数设置线程栈的大小。
栈大小与线程数的关系。
堆的比例分配
-XX:SurvivorRatio 是用来设置新生代中， eden 空间和s0空间的比例关系。 s0和s1空间又分别被称为from空间和to空间。
参数总结：
垃圾收集
垃圾收集算法与思想
-
引用计数器(Reference Counting)
对于一个对象A, 只要有任何一个对象引用了A, 则A的引用计数器就加1 ， 当引用失效时， 引用计数器就减1. 只要对象A的引用计数器的值为0， 则对象A就不可能再被使用。
但由于垃圾对象间相互引用，从而使垃圾回收器无法识别，引起内存泄漏
因此，在Java语言中，单纯的使用引用计数器算法实现垃圾回收是不可行的。
-
标记-清除算法(Mark-Sweep)
将垃圾回收分为两个阶段：标记阶段和清除阶段。
一个可行的实现是， 在标记阶段，首先通过根节点，标记所有从根节点开始的可达对象。因此，未被标记的对象就是未被引用的垃圾对象。然后，在清除阶段，清除所有未被标记的对象。标记-清除算法可能产生的最大问题就是空间碎片。
-
复制算法(Copying)
与标记-清除算法相比，复制算法是一种相当高效的回收方法。它的核心思想是：将原有的内存空间分为两块，每次只使用其中一块，在垃圾回收时，将正在使用的内存对象复制到未使用的内存块中，之后，清除正在使用的内存块中的所有对象，交换两个内存的角色，完成垃圾收集。
但是， 复制算法的代价缺点是将系统内存折半，因此，单纯的复制算法也很难让人接受。
-
标记-压缩算法(Mark-Compact)
标记-压缩算法是一种老年代的回收算法，它在标记-清除算法的基础上做一些优化， 和标记-清除算法一样，标记-压缩算法也首先从根节点开始，对所有可达对象做一次标记。
5.增量算法(Incremental Collecting)
如果一次性将所有的垃圾进行处理，需要造成系统长时间的停顿，那么就可以让垃圾收集线程和应用程序线程交替执行。每次，垃圾收集线程只收集一小片区域的内存空间，接着切换到应用程序线程，如此反复，知道垃圾收集完成。 -
分代(Generational Collecting)
将内存区间根据对象的特点分成几块，根据每块内存区间的特点，使用不同的回收算法，以提高垃圾回收的效率。
垃圾收集器的分类
评价GC策略的指标
吞吐量： 在应用程序的生命周期内， 应用程序所花费的时间和系统总运行时间的比值。
垃圾回收器负载： 垃圾回收器负载指垃圾回收器耗时与系统运行总时间的比值
停顿时间： 垃圾回收器正在运行时，应用程序的暂停时间。
垃圾回收频率： 指垃圾回收器多长时间会运行一次。
反应时间： 指当一个对象称为垃圾后， 多长时间内，它所占据的内存空间会被释放。
堆分配： 不同的垃圾回收器对内存的分配方式可能是不同的。一个良好的垃圾收集器应该有一个合理的堆内存区间划分。
常用调优案例和方法
- 将新对象预留在新生代
Full GC的成本要远远高于Minor GC, 因此尽可能将对象分配在新生代是一项明智的做法。虽然在大部分情况下，JVM会尝试在eden 区分配对象，但是由于空间紧张等问题，很可能不得不将部分年轻对象提前向老年代压缩。因此，在JVM参数调优中，可以为应用程序分配一个合理的新生代空间，以最大限度避免新对象直接进入老年代的情况。
看以下例子，
package com.oscar999.performance.JVMTune;
public class PutInEden {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
byte[] b1,b2,b3,b4;
b1 = new byte[1024*1204];
b2 = new byte[1024*1204];
b3 = new byte[1024*1204];
b4 = new byte[1024*1204];
}
}
当新生代大小设置为 1 M时， 也就是如下命令运行：
java -XX:+PrintGCDetails -Xmx20M -Xms20M -Xmn1M com.oscar999.performance.JVMTune.PutInEden
当新生代设置为 6 M时，
java -XX:+PrintGCDetails -Xmx20M -Xms20M -Xmn6M com.oscar999.performance.JVMTune.PutInEden
类似地， 使用-XX:NewRatio等参数也可以指定新生代大小。 通过设置一个较大的新生代预留新对象，设置合理的survivor 区并且提高survivor区的使用率，可以将年轻对象保留在新生代。一般来说，当 survivor 区的空间不够，或者占用量达到 50%时，就会将对象进入老年代。
- 大对象进入老年代
大对象出现在新生代很可能扰乱新生代GC, 并破坏新生代原有的结构对象。因为尝试在新生代分配大对象，很可能导致空间不足，为了有足够的空间容纳大对象， JVM不得不将新生代中的年轻对象挪到老年代。因为大对象占用空间多，所以, 可能需要移动大量小的年轻对象进入老年代，这对于GC老说相当不利。
可以将大对象直接分配到老年代，保持新生代对象结构的完整性，以提高GC的效率。
软件开发过程中， 应该尽可能避免使用短命的大对象。
可以使用参数-XX:PretenureSizeThreshold 设置大对象直接进入老年代的阈值。当对象的大小超过这个值时，将直接在老年代分配。
注意：这个参数只对串行收集器和新生代并行收集器有效，并行收集器不识别这个参数。
看例子：
package com.oscar999.performance.JVMTune;
public class BigObj2Old {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
byte[] b1;
b1 = new byte[1024*1024];
}
}
使用如下命令：
java -XX:+PrintGCDetails -Xmx20M -Xms20M com.oscar999.performance.JVMTune.BigObj2Old
可以看到， 该对象被分配到了新生代，并几乎占满了整个新生代。
如果使用如下命令：
java -XX:+PrintGCDetails -Xmx20M -Xms20M -XX:PretenureSizeThreshold=1000000 com.oscar999.performance.JVMTune.BigObj2Old
可以看到， 1MB的字节数组已经分配在老年代。
设置对象进入老年代的年龄
一般情况下， 年轻对象存放在新生代，年老对象存放在老年代。 为了做到这点，虚拟机为每个对象都维护一个年龄。
如果对象在eden 区，经过一次GC后还存活，则被移动到survivior区中，对象年龄加1， 以后对象每经过一次GC依然存活的，则年龄再加1. 当对象年龄达到阈值时，就移入老年代，成为老年对象。
这个阈值的最大值通过参数： -XX:MaxTenuringThreshold来设置，它的默认值是15.稳定与震荡的堆大小
一般来说，稳定的堆大小是对垃圾回收有利的。获得一个稳定的堆大小的方法就是使 -Xms 和-Xmx的大小一致，即最大堆和最小堆一样。如果这样设置，系统在运行时，堆大小是恒定的，稳定的堆空间可以减少GC的次数。因此，很多服务端应用都会将最大堆和最小堆设置为相同的数值。
稳定的堆大小虽然可以减少GC次数， 但同时也增加了每次GC的时间。让堆大小在一个区间中震荡，在系统不惜要使用大内存时，压缩堆空间，使GC应对一个较小的堆，可以加快单次GC的速度。基于此， JVM还提供了两个参数用于压缩和扩展堆空间：
-XX:MinHeapFreeRatio: 设置堆空间最小空闲比例。默认是40. 当堆空间的空闲内存小于这个数值时， JVM便会扩展堆空间。
-XX:MaxheapFreeRatio: 设置堆空间最大空闲比例。 默认是70.当堆空间的空闲内存大于这个数值时，便会压缩堆空间， 得到一个较小的堆。
当-Xms和-Xmx相等时， -XX:MinHeapFreeRation和-XX:MaxHeapFreeRatio 这两个参数是无效的。-
吞吐量优先案例
尽可能减少系统的执行垃圾回收的总时间。
看如下设置：
使用大页案例
在Solaris 系统中， JVM 可以支持大页的使用， 使用大的内存分页可以增强CPU的内存寻址能力，从而提升系统的性能
