1.什么是内存溢出

内存溢出是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。

2.引起内存溢出的原因

　　1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；

　　2.集合类中有对对象的引用，使用完后未清空，使得JVM不能回收；

　　3.代码中存在死循环或循环产生过多重复的对象实体；

　　4.使用的第三方软件中的BUG；

　　5.启动参数内存值设定的过小；

3.内存溢出解决方案

第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)

第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

4.出现内存溢出如何排查

1.检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。

2.检查代码中是否有死循环或递归调用。?

3.检查是否有大循环重复产生新对象实体。?

4.检查List、MAP等集合对象是否有使用完后，未清除的问题。List、MAP等集合对象会始终存有对对象的引用，使得这些对象不能被GC回收。

5.内存溢出分类

主要是堆堆溢出:

a.内存泄露:是指对象实例在新建和使用完毕后,仍然被引用,没能被垃圾回收释放,一直累计只到没有剩余的内存可用;

b.内存溢出:当我们新建一个实例对象时,实例对象所需占用的内存空间大于堆的可用空间.

一、基本概念


1，内存溢出 out of memory：
程序运行过程中申请的内存 > 系统能够提供的内存，导致无法申请到足够的内存 ；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
举个例子 需求> 供应，当欲望>工资 时候，就会发生 OOM；

1，内存泄露 memory leak：
内存泄漏指程序运行过程中分配内存给临时变量，用完之后却没有被GC回收，始终占用着内存，既不能被使用也不能分配给其他程序，于是就发生了内存泄漏。比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出.
举个例子 油罐里的资源（石油）被人偷了部分，偷走的石油无法被控制，导致“泄露”；  

memory leak会最终会导致out of memory！
二、内存溢出OOM常见情况
内存溢出有以下几种常见的情况：
1、java.lang.OutOfMemoryError: PermGen space (持久带溢出)

我们知道jvm通过持久带实现了java虚拟机规范中的方法区，而运行时常量池就是保存在方法区中的，因此发生这种溢出可能是运行时常量池溢出，或是由于程序中使用了大量的jar或class，使得方法区中保存的class对象没有被及时回收或者class信息占用的内存超过了配置的大小。

2、java.lang.OutOfMemoryError: Java heap space (堆溢出)

发生这种溢出的原因一般是创建的对象太多，在进行垃圾回收之前对象数量达到了最大堆的容量限制。

解决这个区域异常的方法一般是通过内存映像分析工具对Dump出来的堆转储快照进行分析，看到底是内存溢出还是内存泄漏。如果是内存泄漏，可进一步通过工具查看泄漏对象到GC Roots的引用链，定位出泄漏代码的位置，修改程序或算法；如果不存在泄漏，就是说内存中的对象确实都还必须存活，那就应该检查虚拟机的堆参数-Xmx(最大堆大小)和-Xms(初始堆大小)，与机器物理内存对比看是否可以调大。
3、虚拟机栈和本地方法栈溢出

如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError。

如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError。
三、内存泄漏常见情况
1，为什么会发生内存泄露
来先看看下面的例子，为什么会发生内存泄漏。下面这个例子中，A对象引用B对象，A对象的生命周期（t1-t4）比B对象的生命周期（t2-t3）长的多。当B对象没有被应用程序使用之后，A对象仍然在引用着B对象。这样，垃圾回收器就没办法将B对象从内存中移除，从而导致内存问题，因为如果A引用更多这样的对象，那将有更多的未被引用对象存在，并消耗内存空间。
B对象也可能会持有许多其他的对象，那这些对象同样也不会被垃圾回收器回收。所有这些没在使用的对象将持续的消耗之前分配的内存空间。


内存管理的目的就是让我们在开发中怎么有效的避免我们的应用出现内存泄漏的问题。
2，Java 内存分配策略
Java 程序运行时的内存分配策略有三种,分别是静态分配,栈式分配,和堆式分配，对应的，三种存储策略使用的内存空间主要分别是静态存储区（也称方法区）、栈区和堆区。
3，内存泄漏分类
以发生的方式来分类，内存泄漏可以分为4类：

常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。
偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。
一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。
隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。

从用户使用程序的角度来看，内存泄漏本身不会产生什么危害，作为一般的用户，根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积，这会最终消耗尽系统所有的内存。从这个角度来说，一次性内存泄漏并没有什么危害，因为它不会堆积，而隐式内存泄漏危害性则非常大，因为较之于常发性和偶发性内存泄漏它更难被检测到
4，常见内存泄漏case

静态集合类引起的内存泄漏：

像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，从而造成内存泄漏，因为他们也将一直被Vector等引用着。
        Vector<Object> v=new Vector<Object>(100);
        for (int i = 1; i<100; i++)
        {
            Object o = new Object();
            v.add(o);
            o = null;
        }

在这个例子中，循环申请Object 对象，并将所申请的对象放入一个Vector 中，如果仅仅释放引用本身（o=null），那么Vector 仍然引用该对象，所以这个对象对GC 来说是不可回收的。因此，如果对象加入到Vector 后，还必须从Vector 中删除，最简单的方法就是将Vector对象设置为null。

修改HashSet中对象的参数值，且参数是计算哈希值的字段

当一个对象被存储到HashSet集合中以后，修改了这个对象中那些参与计算哈希值的字段后，这个对象的哈希值与最初存储在集合中的就不同了，这种情况下，用contains方法在集合中检索对象是找不到的，这将会导致无法从HashSet中删除当前对象，造成内存泄漏，举例如下：
public static void main(String[] args){

    Set<Person> set = new HashSet<Person>();
    Person p1 = new Person("张三","1",25);
    Person p2 = new Person("李四","2",26);
    Person p3 = new Person("王五","3",27);
    set.add(p1);
    set.add(p2);
    set.add(p3);
    System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:3 个元素!
    p3.setAge(2); //修改p3的年龄,此时p3元素对应的hashcode值发生改变
    set.remove(p3); //此时remove不掉，造成内存泄漏
    set.add(p3); //重新添加，可以添加成功
    System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:4 个元素!
    
    for (Person person : set){
        System.out.println(person);
    }
}



监听器

在java 编程中，我们都需要和监听器打交道，通常一个应用当中会用到很多监听器，我们会调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而增加了内存泄漏的机会。


各种连接
比如数据库连接（dataSourse.getConnection()），网络连接(socket)和io连接，除非其显式的调用了其close() 方法将其连接关闭，否则是不会自动被GC 回收的。对于Resultset 和Statement 对象可以不进行显式回收，但Connection 一定要显式回收，因为Connection 在任何时候都无法自动回收，而Connection一旦回收，Resultset 和Statement 对象就会立即为NULL。但是如果使用连接池，情况就不一样了，除了要显式地关闭连接，还必须显式地关闭Resultset Statement 对象（关闭其中一个，另外一个也会关闭），否则就会造成大量的Statement 对象无法释放，从而引起内存泄漏。这种情况下一般都会在try里面去连接，在finally里面释放连接。


单例模式
如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露。
不正确使用单例模式是引起内存泄露的一个常见问题，单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露，考虑下面的例子：


class A{
    public A(){
        B.getInstance().setA(this);
    }
    ....
}
//B类采用单例模式
class B{
    private A a;
    private static B instance=new B();
    public B(){}
    
    public static B getInstance(){
        return instance;
    }
    
    public void setA(A a){
        this.a=a;
    }
    //getter...
}

显然B采用singleton模式，它持有一个A对象的引用，而这个A类的对象将不能被回收。想象下如果A是个比较复杂的对象或者集合类型会发生什么情况。
4，避免内存泄漏建议


尽早释放无用对象的引用。


避免在循环中创建对象。


使用字符串处理时避免使用String，应使用StringBuffer。


尽量少使用静态变量，因为静态变量存放在永久代，基本不参与垃圾回收。


参考链接：

https://blog.csdn.net/qq_35642036/article/details/82809780
https://www.cnblogs.com/xiaoxi/p/7354857.html
https://blog.csdn.net/qq_36576738/article/details/55203035

jvm 内存溢出-直接内存溢出
DirectMemory 容量可通过 -XX：MaxDirectMemorySize 指定，如果不指定，则默认与 Java 堆最大值（ -Xmx 指定）一样，下面程序利用 DirectByteBuffe 模拟直接内存溢出的情况
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class DirectBufferOom {
  public static void main(String[] args) {
    final int _1M = 1024 * 1024;
    List<ByteBuffer> buffers = new ArrayList<>();
    int count = 1;
    while (true) {
      ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);
      buffers.add(byteBuffer);
      System.out.println(count++);
    }
  }
}


在命令行运行 java -XX:MaxDirectMemorySize=10M DirectBufferOom ,很快控制台就会出现异常
Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
    at java.nio.Bits.reserveMemory(Bits.java:695)
    at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
    at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
    at DirectBufferOom.main(DirectBufferOom.java:12)

其实它并没有真正向操作系统申请分配内存，而是通过计算得知内存无法分配，于是手动抛出异常。下面的程序利用 Unsafe 类模拟直接内存溢出
import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class UnsafeOom {
  private static final int _1M = 1024 * 1024;

  public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException {
    Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
    unsafeField.setAccessible(true);
    Unsafe unsafe = (Unsafe) unsafeField.get(null);
    while (true) {
      unsafe.allocateMemory(_1M);
    }
  }
}


在命令行运行 java -XX:MaxDirectMemorySize=10M UnsafeOom ,结果如下
Exception in thread"main"java.lang.OutOfMemoryError
at sun.misc.Unsafe.allocateMemory（Native Method）
at org.fenixsoft.oom.DMOOM.main（DMOOM.java：20）


由 DirectMemory 导致的内存溢出，一个明显的特征是在 Heap Dump 文件中不会看见明显的异常，如果读者发现 OOM 之后 Dump 文件很小，而程序中又直接或间接使用了 NIO ，那就可以考虑检查一下是不是这方面的原因。

前言
在实际开发中，我们经常会遇到oom，即所谓的内存溢出情况，对于内存溢出，我们需要搞清楚具体内存的溢出原因，然后对症下药。这里和大家一起学习一下永久代内存溢出。
永久代内存溢出概述
对于JVM的分代策略，想必大家都清楚。之所以对内存进行分代是为了能够更有效的对内存进行回收，对于jvm的分代，大家有兴趣的可以学习，这点不重点讲述。在jvm中的永久代中主要存放是经过几次GC之后依旧没有被回收的对象，而永久代不是经常进行GC，所以在项目运行汇总，如果加载了大量的类，永久代没有及时的回收，后面再向永久代中分配内存的时候，发现已经没有内存可以分配，就会出现下面这货


对于解决上面的异常，我们首先需要了解jvm中几个内存参数

– -XX:+HeapDumpOnOutofMemoryError，dump的时候转储堆快照

– -Xms 堆最小容量(heap min size)

– -Xmx 堆最大容量(heap max size)

– -Xss 栈容量(stack size)

– -XX:PermSize=size 永生代最小容量

– -XX:MaxPermSize=size 永生代最大容量

一般我们在遇到内存溢出的时候首先想到的就是增加上面这些参数值。我们需要根据我们的实际情况来设置我们的内存参数，如果是堆内存溢出，我们应该增加堆内存参数而不是栈内存参数和永久代内存参数，找过具体的内存溢出类型然后修改对应的参数，这种方式比较好，同时增加内存这种固化的解决方式有时候确实能够解决内存溢出问题，但是如果是我们代码本身有内存泄露的漏洞的话，上面的方法无异乎于扬汤止沸。这时候我们就需要一些工具来具体查看内存泄露和溢出的原因了，这里不做深究。
如何修改上面的参数值
首先我们如果是在IDE工具上发布项目，比如说eclipse,这时候发现了永久代内存溢出，那么我们就需要从eclipse上修改一些默认的内存参数。

我们可以找到eclispe上的window菜单栏，找到preferences,再找到java选项，然后在找到对应的installed jre,编辑对应的java运行环境，如下图


在default vm arguments来设置全局内存参数，这里如-Xms256m -Xmx512m -XX:MaxNewSize=256m -XX:MaxPermSize=512m然后点击保存。


然后重新发布项目，可以在console窗口中查看这样的参数来验证自己的vm arguments设置是否有效


如果我们是将项目打成war包形式进行发布，在运行的过程中出现的了内存溢出，那么我们可以在tomcat上面修改启动参，在tomcat的bin目录下main找到catalina.bat直接右击编辑。然后在“rem ----- Execute The Requested Command ----------------------”下面加上参数设置，JAVA_OPTS="-server -Xms800m -Xmx800m -XXNewSize=256M -XX:PermSize=256M -XX:MaxNewSize=512m -XX:MaxPermSize=512m"，当然具体的内存大小要结合自己设备的可用内存来确定，不能一味的设置大数字，这样可能会导致tomcat启动不了。


需要注意的是，如果我们在eclipse中运行项目，结果出现永久代内存溢出的情况，我们最好采用第一种方式来修改内存参数，如果直接在tomcat中的catelina.bat中修改可能没有作用，这点需要注意。当然还要其他方式设置参数，例如在eclipse的安装目录下面的eclipse.ini文件中直接设置启动参数也是可以的。