一、内存泄漏的理解与分类

1.1、何为内存泄漏

image.png
可达性分析算法来判断对象是否是不再使用的对象，本质都是判断一个对象是否还被引用。那么对于这种情况下，由于代码的实现不同就会出现很多种内存泄漏问题（让JVM误以为此对象还在引用中，无法回收，造成内存泄漏）。

  • 是都还被试用？
  • 是否还被需要？

    1.2、内存泄漏（memory leak）的理解

    严格来说，只有对象不会再被程序用到了，但是Gc又不能回收他们的情况，才叫内存泄漏。
    但实际情况很多时候一些不太好的实践（或疏忽）会导致对象的生命周期变得很长甚至导致OOM，也可以叫做宽泛意义上的“内存泄漏”。
    image.png

对象×引用对象 Y，x的生命周期比Y 的生命周期长;
那么当Y生命周期结束的时候，x依然引用着Y，这时候，垃圾回收期是不会回收对象Y的;
如果对象x还引用着生命周期比较短的A、B、C，对象A又引用着对象 a、b、c，这样就可能造成大量无用的对象不能被回收，进而占据了内存资源，造成内存泄漏，直到内存溢出。

1.3、内存泄漏与内存溢出的关系：

1.3.1、内存泄漏（ memory leak )

申请了内存用完了不释放，比如一共有1024M 的内存，分配了512M的内存一直不回收，那么可以用的内存只有521M 了，仿佛泄露掉了一部分;
通俗一点讲的话，内存泄漏就是【占着茅坑不拉shi】。

1.3.2、内存溢出（out of memory)

申请内存时，没有足够的内存可以使用;
通俗一点儿讲，一个厕所就三个坑，有两个站着茅坑不走的（内存泄漏），剩下最后一个坑，厕所表示接待压力很大，这时候一下子来了两个人，坑位（内存）就不够了，内存泄漏变成内存溢出了。

可见，内存泄漏和内存溢出的关系:内存泄漏的增多，最终会导致内存溢出。

1.4、泄漏的分类

  • 经常发生: 发生内存泄露的代码会被多次执行，每次执行，泄露一块内存;
  • 偶然发生: 在某些特定情况下才会发生;
  • 一次性: 发生内存泄露的方法只会执行一次;

  • 隐式泄漏: 一直占着内存不释放，直到执行结束;严格的说这个不算内存泄漏，因为最终释放掉了,

    二、Java内存泄漏的8中情况

    2.1-静态集合类

    静态集合类，如HashMap、LinkedList等等。如果这些容器为静态的，那么它们的生命周期与JVM程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。简单而言，长生命周期的对象持有短生命周期对象的引用，尽管短生命周期的对象不再使用，但是因为长生命周期对象持有它的引用而导致不能被回收。

    1. public class MemoryLeak {
    2.   static List list = new ArrayList();
    3.   public void oomTests() {
    4.       //局部变量
    5.       Object obj = new Object();
    6.       list.add(obj);
    7.   }
    8. }

    2.2-单例模式

    单例模式，和静态集合导致内存泄露的原因类似，因为单例的静态特性，它的生命周期和JVM 的生命周期一样长，所以如果单例对象如果持有外部对象的引用，那么这个外部对象也不会被回收，那么就会造成内存泄漏。

    2.3-内部类持有外部类

    内部类持有外部类，如果一个外部类的实例对象的方法返回了一个内部类的实例对象。
    这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持有外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄漏。

    2.4-各种连接，如数据库连接、网络连接和IO连接等

    各种连接，如数据库连接、网络连接和IO连接等。
    在对数据库进行操作的过程中，首先需要建立与数据库的连接，当不再使用时，需要调用close方法来释放与数据库的连接。只有连接被关闭后，垃圾回收器才会回收对应的对象。
    否则，如果在访问数据库的过程中，对Connection、Statement或ResultSet不显性地关闭，将会造成大量的对象无法被回收，从而引起内存泄漏。

    1. pubiic static void main( string[ ] args) {
    2.   try {
    3.       Connection conn = null;
    4.       Class.forName( "com.mysql.jdbc.Driver" );
    5.       conn = DriverManager.getConnection( "ur1","","");
    6.       Statement stmt = conn.createstatement();
    7.       Resultset rs = stmt.executeQuery("....");
    8.   }catch(Exception e){//异常日志
    10.   }finally{
    11.       //1.关闭结果集Statement
    12.       //2.关闭声明的对象ResultSet
    13.       //3.关闭连接Connection 
    14.   }
    15. }

    2.5-变量不合理的作用域

    变量不合理的作用域。一般而言，一个变量的定义的作用范围大于其使用范围，很有可能会造成内存泄漏。另一方面，如果没有及时地把对象设置为null，很有可能导致内存泄漏的发生。

    1. public class UsingRandom {
    2.   private String msg;
    3.   public void receiveMsg(){
    4.       readFromNet( );//从网络中接受数据保存到msg中
    5.       saveDB();//把msg保存到数据库中
    6.   }
    7. }

    如上面这个伪代码，通过readFromNet方法把接受的消息保存在变量msg中，然后调用saveDB方法把msg的内容保存到数据库中，此时msg已经就没用了，由于msg的生命周期与对象的生命周期相同，此时msg还不能回收，因此造成了内存泄漏。

实际上这个msg变量可以放在receiveMsg方法内部，当方法使用完，那么msg的生命周期也就结束，此时就可以回收了。还有一种方法，在使用完msg后，把msg设置为null，这样垃圾回收器也会回收msg的内存空间。

2.6-改变哈希值

改变哈希值，当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了。
否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄漏。

这也是 String为什么被设置成了不可变类型，我们可以放心地把 String存入 HashSet，或者把String当做HashMap的key值;

当我们想把自己定义的类保存到散列表的时候，需要保证对象的 hashCode不可变。
举例1:

  1. package studies.memoryyleak;
  2. import java.util.HashSet;
  3. /**
  4.  * @Date: 2021/5/18
  5.  * @Time: 13:40
  6.  * @BelongsProject base
  7.  * @BelongsPackage studies.memoryyleak
  8.  * 演示内存泄漏
  9.  */
  10. public class ChangeHashCode1 {
  11.     public static void main(String[] args) {
  12.         HashSet<Point>  hs = new HashSet<>();
  13.         Point cc = new Point();
  14.         //hashCode = 41;
  15.         cc.setX(10);
  16.         hs.add(cc);
  17.         //hashCode = 51，此行为导致了内存的泄漏，
  18.         cc.setX(20);
  19.         //false因为HashSet是根据对象的hashCode来寻找存储位置
  20.         System.out.println("hs.remove = "+hs.remove(cc));
  21.         hs.add(cc);
  22.         //size = 2;
  23.         System.out.println("hs.size = "+hs.size());
  24.         System.out.println(hs);
  25.     }
  26. }
  27. class Point{
  28.     int x;
  30.     public int getX() {
  31.         return x;
  32.     }
  34.     public void setX(int x) {
  35.         this.x = x;
  36.     }
  37.     @Override
  38.     public int hashCode(){
  39.         final int prime = 31;
  40.         int result = 1;
  41.         result = prime * result + x;
  42.         return result;
  43.     }
  45.     @Override
  46.     public boolean equals(Object o) {
  47.         if (this == o) {
  48.             return true;
  49.         }
  50.         if (o == null || getClass() != o.getClass()) {
  51.             return false;
  52.         }
  53.         Point point = (Point) o;
  54.         return x == point.x;
  55.     }
  57.     @Override
  58.     public String toString() {
  59.         return "Point{" +
  60.                 "x=" + x +
  61.                 '}';
  62.     }
  63. }

举例2:

  1. package studies.memoryyleak;
  2. import java.util.HashSet;
  3. /**
  4.  * @author: wuchang
  5.  * @Date: 2021/5/19
  6.  * @Time: 7:29
  7.  * @BelongsProject base
  8.  * @BelongsPackage studies.memoryyleak
  9.  * 演示内存泄漏
  10.  */
  11. public class ChangeHashCode {
  12.     public static void main(String[] args) {
  13.         HashSet set = new HashSet();
  14.         Person p1 = new Person(1001, "AA");
  15.         Person p2 = new Person(1002, "BB");
  16.         set.add(p1);
  17.         set.add(p2);
  18.         //导致了内存的泄漏
  19.         p1.name = "CC";
  20.         //删除失败
  21.         set.remove(p1);
  22.         System.out.println(set);
  23.         //根据cc的hashCode，当前的1001不会跟已经存入1001进行equals比较
  24.         //所以能存进去
  25.         set.add(new Person(1001,"CC"));
  26.         System.out.println(set);
  27.         //虽然这里1001的hashCode值跟第一存入的是一样的，
  28.         // 但进行equals比较的时候name值不一样所以也能存进去
  29.         set.add(new Person(1001,"AA"));
  30.         System.out.println(set);
  31.     }
  32. }
  33. class Person{
  34.     int id;
  35.     String name;
  37.     public Person(int id, String name) {
  38.         this.id = id;
  39.         this.name = name;
  40.     }
  42.     @Override
  43.     public boolean equals(Object o) {
  44.         if (this == o) return true;
  45.         if (o == null || getClass() != o.getClass()) return false;
  46.         Person person = (Person) o;
  47.         return id == person.id && name.equals(person.name);
  48.     }
  50.     @Override
  51.     public int hashCode() {
  52.         int result = id;
  53.         result = 31 * result + (name != null ? name.hashCode() : 0);
  54.         return result;
  55.     }
  57.     @Override
  58.     public String toString() {
  59.         return "Person{" +
  60.                 "id=" + id +
  61.                 ", name='" + name + '\'' +
  62.                 '}';
  63.     }
  64. }

2.7-缓存泄漏

内存泄漏的另一个常见来源是缓存，一旦你把对象引用放入到缓存中，他就很容易遗忘。比如:之前项目在一次上线的时候，应用启动奇慢直到夯死，就是因为代码中会加载一个表中的数据到缓存（内存)中，测试环境只有几百条数据，但是生产环境有几百万的数据。

对于这个问题，可以使用WeakHashMap代表缓存，此种Map的特点是，当除了自身有对key的引用外，此key没有其他引用那么此map会自动丢弃此值。
例子：

  1. package studies.memoryyleak;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import java.util.WeakHashMap;
  5. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * @Date: 2021/5/19
  8.  * @Time: 7:54
  9.  * @BelongsProject base
  10.  * @BelongsPackage studies.memoryyleak
  11.  */
  12. public class MapTest {
  13.     static Map wMap = new WeakHashMap();
  14.     static Map map = new HashMap();
  16.     public static void main(String[] args) {
  17.         init();
  18.         testWeakHashMap();
  19.         testHashMap();
  21.     }
  22.     public static void init(){
  23.         String ref1 = new String( "obejct1");
  24.         String ref2 = new String( "obejct2");
  25.         String ref3 = new String( "obejct3");
  26.         String ref4 = new String( "obejct4");
  27.         wMap.put(ref1, "cacheObject1");
  28.         wMap.put(ref2, "cacheObject2");
  29.         map.put(ref3, "cacheObject3");
  30.         map.put(ref4, "cacheObject4");
  31.         System.out.println("String引用ref1，ref2，ref3，ref4 消失");
  32.     }
  34.     public static void testWeakHashMap(){
  35.         System.out.println( "WeakHashMap GC之前");
  36.         for (Object o : wMap.entrySet()){
  37.             System.out.println(o);
  38.         }
  39.         System.gc();
  40.         try {
  41.             TimeUnit.SECONDS.sleep(5);
  42.         } catch (InterruptedException e) {
  43.             e.printStackTrace();
  44.         }
  45.         System.out.println("WeakHashMap GC之后");
  46.         for (Object o : wMap.entrySet()){
  47.             System.out.println(o);
  48.         }
  49.     }
  51.     public static void testHashMap(){
  52.         System.out.println( "testHashMap GC之前");
  53.         for (Object o : map.entrySet()){
  54.             System.out.println(o);
  55.         }
  56.         System.gc();
  57.         try {
  58.             TimeUnit.SECONDS.sleep(5);
  59.         } catch (InterruptedException e) {
  60.             e.printStackTrace();
  61.         }
  62.         System.out.println("testHashMap GC之后");
  63.         for (Object o : map.entrySet()){
  64.             System.out.println(o);
  65.         }
  66.     }
  67. }
  68. ///////////////////////////
  69. 控制台输出：
  70. String引用ref1，ref2，ref3，ref4 消失
  71. WeakHashMap GC之前
  72. obejct2=cacheObject2
  73. obejct1=cacheObject1
  74. WeakHashMap GC之后
  75. testHashMap GC之前
  76. obejct4=cacheObject4
  77. obejct3=cacheObject3
  78. testHashMap GC之后
  79. obejct4=cacheObject4
  80. obejct3=cacheObject3

image.png
上面代码和图示主演演示WeakHashMap如何自动释放缓存对象，当init函数执行完成后，局部变量宁符串引用weakd1,weakd2,d1,d2都会消失，此时只有静态map中保存中对字符串对象的引用，可以看到，调用gc之后，HashMap的没有被回收，而WeakHashMap里面的缓存被回收了。

2.8-监听器和回调

内存泄漏另一个常见来源是监听器和其他回调，如果客户端在你实现的APT中注册回调，却没有显示的取消，那么就会积聚。

需要确保回调立即被当作垃圾回收的最佳方法是只保存它的弱引用，例如将他们保存成为weakHashMap中的键。

三、内存泄漏案例分析

3.1、案例1

3.1.1、案例代码

  1. package studies.memoryyleak;
  2. import java.util.Arrays;
  3. import java.util.EmptyStackException;
  4. /**
  5.  * @Date: 2021/5/19
  6.  * @Time: 8:11
  7.  * @BelongsProject base
  8.  * @BelongsPackage studies.memoryyleak
  9.  */
  10. public class Stack {
  11.     private Object[] elements;
  12.     private int size = 0;
  13.     private static final int DEFAULT_INITIAL_CAPACITY = 16;
  14.     public Stack(){
  15.         elements = new Object[DEFAULT_INITIAL_CAPACITY];
  16.     }
  18.     //入栈
  19.     public void push(Object e){
  20.         ensureCapacity();
  21.         elements[size++] = e;
  22.     }
  24.     //出栈（存在内存泄漏）
  25.     public Object pop(){
  26.         if (size == 0){
  27.             throw new EmptyStackException();
  28.         }
  29.         return elements[--size];
  30.     }
  32.     //不存在内存泄漏
  33.     /*public Object pop(){
  34.         if (size == 0){
  35.             throw new EmptyStackException();
  36.         }
  37.         Object result = elements[--size];
  38.         elements[size] = null;
  39.         return result;
  40.     }*/
  42.     //数组扩容
  43.     private void ensureCapacity(){
  44.         if (elements.length == size){
  45.             elements = Arrays.copyOf(elements, 2 * size + 1);
  46.         }
  47.     }
  48. }

3.1.2、分析

上述程序并没有明显的错误，但是这段程序有一个内存泄漏，随着GC活动的增加，或者内存占用的不断增加，程序性能的降低就会表现出来，严重时可导致内存泄漏，但是这种失败情况相对较少。代码的主要问题在pop函数，下面通过这张图示展现
假设这个栈一直增长，增长后如下图所示
image.png
当进行大量的pop操作时，由于引用未进行置空，gc是不会释放的，如下图所示
image.png
从上图中看以看出，如果栈先增长，在收缩，那么从栈中弹出的对象将不会被当作垃圾回收，即使程序不再使用栈中的这些队象，他们也不会回收，因为栈中仍然保存这对象的引用，俗称过期引用，这个内存泄露很隐蔽。

3.1.3、解决办法

  1. public Object pop(){
  2.         if (size == 0){
  3.             throw new EmptyStackException();
  4.         }
  5.         Object result = elements[--size];
  6.         elements[size] = null;
  7.         return result;
  8.     }

一旦引用过期，清空这些引用，将引用置空。
image.png

3.2、案例2

3.2.1、案例代码

移动端的案例：
image.png

3.2.2、分析

image.png
image.png

3.2.3、解决办法

1．使用线程时，一定要确保线程在周期性对象〈如Activity）销毁时能正常结束，如能正常结束，但是Activity销毁后还需执行一段时间，也可能造成泄露，此时可采用WeakReference方法来解决，另外在使用Handler的时候，如存在Delay操作，也可以采用weakReference;
2．使用Handler + HandlerThread时，记住在周期性对象销毁时调用looper.quit()方法;