最近做的一个项目中，遇到了内存泄漏的问题，查了很多资料，问题解决后，简单记录下。


一、内存泄漏的概念：

严格意义讲，内存泄露的原因只有一种：没有释放向系统申请的内存，因为不申请内存，就谈不上什么泄露。



二、内存泄漏的原因：

上述提到，内存泄漏就是内存没有释放，而内存没有释放的原因有很多种：可能写代码的时候，忘记了释放自己代码里申请的内存；也有可能是你使用了一个写的不好的库，库本身有问题等。

三、内存泄漏的分类：



（1）常发性内存泄漏：发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。

（2）偶发性内存泄漏：发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。

（3）一次性内存泄漏：发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。

（4）隐式内存泄漏：程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。
四、JS的垃圾收集机制



 JS具有自动垃圾收集机制。即执行环境会负责管理代码执行过程中使用的内存。而在C和C++之类的语言中，开发人员的一项基本任务就是手动跟踪内存的使用情况，这是造成许多问题的一个根源。而在编写JS程序时，开发人员不用再关心内存使用的问题，所需内存的分配以及无用的回收完全实现了自动管理。

 JavaScript中最常用的垃圾收集方式是标记清除(mark-and-sweep)。当变量进入环境（例如，在函数中声明一个变量）时，就将这个变量标记为“进入环境”。从逻辑上讲，永远不能释放进入环境的变量所占的内存，因为只要执行流进入相应的环境，就可能用到它们。而当变量离开环境时，这将其标记为“离开环境”。

五、JS中常见的内存泄漏的原因：

（1）全局变量引起的内存泄漏

  function leaks(){

  leak= 'xxxxxx';

  //leak一个全局变量，不会被回收

  }

 定义过多的全局变量，会造成内存泄漏，因为全局变量申请的内存，不会被释放。

 （2）闭包引起的内存泄漏

   var
 leaks = (function(){

   var leak= 'xxxxxx';//被闭包所引用，不会被回收

   return   function(){

   console.log(leak);

   }
  })()

 变量被闭包函数使用，申请内存不能被释放。

（3）dom清空或删除时，事件未清除导致的内存泄漏

 事件清除前：

 <div id="container"></div>

 $('#container').bind('click', function(){

  
console.log('click');

 }).remove();

 该种方法中，由于事件未被清除，所以remove()无效，这样也会造成内存泄漏。


 事件清除后：

 <div id="container"> </div>

 $('#container').bind('click',function(){

     console.log('click')；

 })

 .off('click')

 .remove();

 把事件清除了，即可从内存中移除。

 另外，在项目中，使用多个定时器，尤其是定时器里面套定时器，也造成了内存的泄漏。建议不要过多使用定器

 ，更不要套用，用了也要记着清掉。


  参考：http://www.xuexila.com/yuanyin/734475.html

  参考：http://www.cnblogs.com/libin-1/p/6013490.html

内存泄漏 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。

一 . 以发生的方式来分类，内存泄漏可以分为4类： 

1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。 

2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。 

3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。 

4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。 

二 . Java内存泄露引起原因 

内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。内存泄露有时不严重且不易察觉，这样开发者就不知道存在内存泄露，但有时也会很严重，会提示你Out of memory。那么，Java内存泄露根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。具体主要有如下几大类

1、静态集合类引起内存泄露(static 对象是不会被GC回收的)：

集合类，如HashMap、Set、ArrayList、Vector等它们是内存泄漏的常见位置。如将他们声明为static，那么它将拥有和主程序一样的生命周期，如果他们里面放置了大量对象（引用的关系），当这些对象不在使用时，因为HashMap，集合等是全局的static类型，那么垃圾回收将无法处理这些不在使用的对象，从而造成了内存泄漏。

public class MemoryLeak{
	static List<Student> list = new ArrayList<Student>();
	
	public static void main(String[] args) 
			throws InterruptedException{
		
		for(int i =0;i<1000000;i++){
			Student stu = new Student();
			list.add(stu);    //内存泄漏，无法回收
		}
		//便于观察虚拟机运行情况
		while(true){
			Thread.sleep(20000);
		}
	}
}
class Student{	
}

2、当集合里面的对象属性被修改后，再调用remove（）方法时不起作用。

public class MemoryLeak2 {
	public static void main(String[] args) {

		Set<Person> set = new HashSet<Person>(); 
		Person p1 = new Person("唐僧","pwd1",25); 
		Person p2 = new Person("孙悟空","pwd2",26); 
		Person p3 = new Person("猪八戒","pwd3",27); 
		set.add(p1); 
		set.add(p2); 
		set.add(p3);//现在set里面有3个对象! 
		p3.setAge(2); //修改p3的年龄,此时p3的hashcode改变 
		set.remove(p3); //此时remove不掉，造成内存泄漏
		set.add(p3); //重新添加，成功，现在set里面有4个对象
	}

}
class Person{
    public Person(){}
    public Person(String name,String pwd,Integer age){
        ...
}

3、各种连接

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

4、单例模式

如果单例对象持有外部对象的引用，那么这个外部对象将不能被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...
}

5、读取流没有关闭

开发中经常忘记关闭流，这样会导致内存泄漏。因为每个流在操作系统层面都对应了打开的文件句柄，流没有关闭，会导致操作系统的文件句柄一直处于打开状态，而jvm会消耗内存来跟踪操作系统打开的文件句柄。

6、监听器

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

7、String的intern方法

在大字符串上调用String.intern() 方法，intern()会将String放在jvm的内存池中（PermGen ），而jvm的内存池是不会被gc的。因此如果大字符串调用intern()方法后，会产生大量的无法gc的内存，导致内存泄漏。如果必须要使用大字符串的intern方法，应该通过-XX:MaxPermSize参数调整PermGen内存的大小(关于设置虚拟机内存大小后续会继续发布相关博客)。

8、 将没有实现hashCode()和equals()方法的对象加入到HashSet中

这是一个简单却很常见的场景。正常情况下Set会过滤重复的对象，但是如果没有hashCode() 和 equals()实现，重复对象会不断被加入到Set中，并且再也没有机会去移除。因此给类都加上hashCode() 和 equals()方法的实现是一个好的编程习惯。可以通过Lombok的@EqualsAndHashCode很方便实现这种功能。

三. 查找内存泄漏的方法

3.1 记录gc日志

通过在jvm参数中指定-verbose:gc，可以记录每次gc的详细情况，用于分析内存的使用。

3.2 进行profiling

通过Visual VM或jdk自带的Java Mission Control，进行内存分析。

3.3 代码审查

通过代码审查和静态代码检查，发现导致内存泄漏问题的错误代码。

四. 总结

代码层面的检查可以帮助发现部分内存泄漏的问题，但是生产环境中的内存泄漏往往不容易提前发现，因为很多问题是在大并发场景下才会出现。因此还需要通过压力测试工具进行压力测试，提前发现潜在的内存泄漏问题。

 

 

一、基本概念


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

一.线程造成的内存泄漏
对于线程造成的内存泄漏，也是平时比较常见的，leakCanary官方Demo就是线程成造成的内存泄漏，使用了AsyncTask去执行异步线程，现在我们换个写法，直接使用Thread：
1. 新建工程，配置好leakCanary环境
2. 直接在MainActivity添加如下代码：


红色方框内的代码，可能每个人都这样写过。
OK ，我们执行一下，然后做如下操作：
1 MainActivity页面打开后，在20秒内点击手机返回键
2. 等待10秒
操作完成，leakCanary检测出内存泄漏。






分析原因：和上面几个案例的原因类似，不知不觉又搞了一个匿名内部类Runnable，对当前Activity都有一个隐式引用。如果Activity在销毁的时候，Runable内部的任务还未完成，
 那么将导致Activity的内存资源无法回收，造成内存泄漏。正确的做法还是使用静态内部类的方式，如下：





上面代码中，自定义了静态的内部类MyRunable，实现了Runable ，然后在使用的时候实例化它。
运行代码后做如上相同操作，发现leakCannary没有检测出内存泄漏。
 


二. 资源未关闭造成的内存泄漏
对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源的代码，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄漏。
 
 
总结：
以上Android开发中常见的内存泄漏问题及解决办法，能对内存泄漏有一定的认识和见解，是同学们面试时的一个极其有利的加分项， 内存泄漏是很多有一定开发经验的程序员都会犯的错误，掌握这些，代表你确确实实做过一些东西，并有一定的总结。