内存溢出

内存溢出（out of memory）：JVM内存区域中，除了程序计数器外，其他几个运行时区域都有可能发生OutOfMemoryError（OOM）异常。

一、Java堆溢出
原因：
1、代码中存在死循环或循环产生过多的对象实体；Java堆用于存储对象实例，只要不断地创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，对象数量达到最大堆容量限制，则发生溢出。
限制Java堆的大小为20MB，最小值和最大值相同（不可扩展）。通过参数-XX:+HeapDumpOnOutOfMemoryError可以让虚拟机出现内存溢出异常时Dump出当前的内存堆转储快照以便事后分析。
/**
 * Java堆溢出
 * VM Args：-Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError
 */

public class HeapOOM {

    public static void main(String[] args) {
        List<OOMObject> list = new ArrayList<OOMObject>();
        while(true) {
            // list保留引用，避免Full GC 回收
            list.add(new OOMObject());
        }
    }

    static class OOMObject {

    }
}

运行结果：
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid7768.hprof ...
Heap dump file created [27987840 bytes in 0.142 secs]


2、一次加载的数据量过于庞大：
1）一次从数据库取出过多数据；
    检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中 数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
2）Bitmap：一次性加载较大的图片会造成内存溢出。bitmap低版本必须recycle，底层用的native实现，否则内存泄露。
    读取图片之前先查看其大小：
    BitmapFactory.Options opts = new BitmapFactory.Options();
    //设置inJustDecodeBounds为true后，decodeFile并不分配内存空间真正加载bitmap，    但是可以获取bitmap的宽高等
    opts.inJustDecodeBounds = true;
    Bitmap bitmap = BitmapFactory.decodeFile(imageFile, opts);
    使用得到的图片原始宽高计算适合自己的smaplesize
    BitmapFactory.Options opts = new BitmapFactory.Options();
     opts.inSampleSize = 4 ;// 4就代表容量变为以前容量的1/4
    opts.inJustDecodeBounds = false;
    Bitmap bitmap = BitmapFactory.decodeFile(imageFile, opts);
    对于过时的Bitmap对象一定要及时recycle，并且把此对象赋值为null。
    bitmap.recycle();
    bitmap = null;



3、memory leak会最终会导致out of memory！




分析
一般先通过内存映像分析工具（如Eclipse Memory Analyzer，即MAT）对Dump出来的堆转储快照进行分析，确实是内存泄露还是内存溢出。
内存泄露：查看泄露对象到GC Roots的引用链，定位泄露代码位置。
内存溢出：如果不存在泄露，即内存中的对象确实都还必须活着，检查JVM堆参数（-Xmx与-Xms），调大参数，检查代码是否存在某些对象生命周期过长，持有状态过长的情况，减少程序运行期的内存消耗。






二、虚拟机栈和本地方法栈溢出：HotSpot不区分虚拟机栈和本地方法栈，栈容量只能由-Xss参数设定。

    StackOverFlow：线程申请的栈深度超过允许的最大深度
    OutOfMemoryError： 虚拟机扩展时无法申请到足够的内存空间

1、StackOverFlow的情况：递归调用方法，定义大量的本地变量，增大此方法帧中本地变量表的长度。
/**
 * 虚拟机栈和本地方法栈溢出 StackOverFlow
 * VM Args：-Xss128k
 */

public class JavaVMStackSOF {

    private int stackLength = 1;

    // 递归调用方法，定义大量的本地变量，增大此方法帧中本地变量表的长度
    public void stackLeak() {
        stackLength++;
        stackLeak();
    }

    public static void main(String[] args) {
        JavaVMStackSOF oom = new JavaVMStackSOF();
        try {
            oom.stackLeak();
        } catch (Throwable e) {
            System.out.println("stack length: " + oom.stackLength);
            throw e;
        }
    }

}

运行结果：
stack length: 999
Exception in thread "main" java.lang.StackOverflowError
    at com.jvm.OutOfMemoryError.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:26)
    at com.jvm.OutOfMemoryError.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:26)
    at com.jvm.OutOfMemoryError.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:26)
    ......


2、OutOfMemoryError：单个线程下，无论由于栈帧太大还是虚拟机栈容量太小，当内存无法分配时，虚拟机都跑出的是StackOverFlow异常。如果测试不断建立多线程，可以产生内存溢出。
原因：多线程下的内存溢出，与栈空间是否足够大并不存在任何联系。为每个线程的栈分配的内存越大（参数-Xss），那么可以建立的线程数量就越少，建立线程时就越容易把剩下的内存耗尽，越容易内存溢出。在这种情况下，如果不能减少线程数目或者更换64位虚拟机时，减少最大堆和减少栈容量能够换区更多的线程。
**
 * 虚拟机栈和本地方法栈溢出
 *
 * !!!!!注意!!!!!
 * 运行该代码可能造成系统假死！！！！
 *
 * VM Args：-Xss2M（可以适当大一点）
 */

public class JavaVMStackOOM {

    private void dontStop() {
        while(true) {

        }
    }

    // 多线程方式造成栈内存溢出 OutOfMemoryError
    public void stackLeakByThread() {
        while(true) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    dontStop();
                }
            });
            thread.start();
        }
    }

    public static void main(String[] args) {
        JavaVMStackOOM oom = new JavaVMStackOOM();
        oom.stackLeakByThread();
    }
}



三：方法区和运行常量池溢出
1、
/**
 * 运行时常量池溢出
 *
 * jdk1.7 及其以后的版本已经“去永久代”，jdk1.6之前的环境下运行才会出现溢出
 * -XX:PermSize=10M -XX:MaxPermSize=10M （间接指定常量池容量大小）
 */

public class RuntimeConstantPoolOOM {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        int i = 0;
        while(true) {
            // list保留引用，避免Full GC 回收
            list.add(String.valueOf(i++).intern());
        }
    }
}




2、
public class RuntimeConstantPoolOOM {  
    public static void main(String[] args) {  
        String str1 = new StringBuilder("计算机").append("软件").toString();  
       // String str3= new StringBuilder("计算机软件").toString();  
        System.out.println(str1.intern() == str1);  

        String str2 = new StringBuilder("Java(TM) SE ").append("Runtime Environment").toString();  
        System.out.println(str2.intern() == str2);  
    }  
}  
如果JDK1.6会返回两个false，JDK1.7运行则会返回一个true一个false。
原因：
    String.intern()是一个Native方法，它的作用是：如果运行时常量池中已经包含一个等于此String对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建与此String内容相同的字符串，并返回常量池中创建的字符串的引用。
    JDK7的intern()方法的实现有所不同，当常量池中没有该字符串时，不再是在常量池中创建与此String内容相同的字符串，而改为在常量池中记录堆中首次出现的该字符串的引用，并返回该引用。str2的比较返回false因为"java"这个字符串在执行StringBuilder.toString()之前已经出现过，字符串常量池中已经有它的引用了，不符合“首次出现”的原则，而“计算机软件”这个字符串是首次出现，因此返回true。



3、方法区用于存放Class的相关信息，如果运行时产生大量的类去填满方法区，就可能发生方法区的内存溢出。 例如主流框架Spring、Hibernate对大量的类进行增强时，利用CGLib字节码生成动态类；大量JSP或动态JSP(JSP第一次运行时需要编译为Java类）。



四、本地直接内存溢出