1- 静态集合类

静态集合类，如HashMap、LinkedList等等。如果这些容器为静态的，那么它们的生命周期与JVM程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。简单而言，长生命周期的对象持有短生命周期对象的引用，尽管短生命周期的对象不再使用，但是因为长生命周期对象持有它的引用而导致不能被回收。
public class MemoryLeak {
static List list = new ArrayList();
public void oomTests() {
Object obj = new Object();//局部变量
list.add(obj);
}
}

2- 单例模式

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

image.png

3- 内部类持有外部类

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

  1. //安卓的例子
  2. public class HandlerDemoActivity extends Activity implements OnClickListener {
  4.   private static final int MESSAGE_INCRESE = 0;
  5.   private static final int MESSAGE_DECRESE = 1;
  6.   private TextView tv_demo_number;
  7.   private Button btn_demo_increase;
  8.   private Button btn_demo_decrease;
  9.   private Button btn_demo_pause;
  11.   private Handler handler = new Handler(){
  12.      //回调方法
  13.      public void handleMessage(android.os.Message msg) {
  14.        String strNum = tv_demo_number.getText().toString();
  15.        //转换为整型数据,获取当前显示的数值
  16.        int num = Integer.parseInt(strNum);
  18.        switch(msg.what){
  19.        case MESSAGE_INCRESE:
  20.           num++;
  21.           tv_demo_number.setText(num + "");
  23.           if(num == 20){
  24.             Toast.makeText(HandlerDemoActivity.this, "已达到最大值", 0).show();
  25.             btn_demo_pause.setEnabled(false);
  26.             return;
  27.           }
  29.           //发送延迟的+1的消息
  30.           sendEmptyMessageDelayed(MESSAGE_INCRESE, 300);//指的是延迟处理，而不是延迟发送
  32.           break;
  33.        case MESSAGE_DECRESE:
  34.           num--;
  35.           tv_demo_number.setText(num + "");
  38.           if(num == 0){
  39.             Toast.makeText(HandlerDemoActivity.this, "已达到最小值", 0).show();
  40.             btn_demo_pause.setEnabled(false);
  41.             return;
  42.           }
  44.           //发送延迟的-1的消息
  45.           sendEmptyMessageDelayed(MESSAGE_DECRESE, 300);//指的是延迟处理，而不是延迟发送
  47.           break;
  48.        }
  50.      }
  51.   };
  53.   @Override
  54.   protected void onCreate(Bundle savedInstanceState) {
  55.      super.onCreate(savedInstanceState);
  56.      setContentView(R.layout.activity_handler_demo);
  57.      init();
  58.   }
  61.   private void init() {
  62.      tv_demo_number = (TextView) findViewById(R.id.tv_demo_number);
  63.      btn_demo_increase = (Button) findViewById(R.id.btn_demo_increase);
  64.      btn_demo_decrease = (Button) findViewById(R.id.btn_demo_decrease);
  65.      btn_demo_pause = (Button) findViewById(R.id.btn_demo_pause);
  67.      btn_demo_increase.setOnClickListener(this);
  68.      btn_demo_decrease.setOnClickListener(this);
  69.      btn_demo_pause.setOnClickListener(this);
  72.   }
  74.   @Override
  75.   public void onClick(View v) {
  76.      ....
  77.   }
  78. }

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

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

  1. public static void main(String[] args) {
  2.     try {
  3.         Connection conn = null;
  4.         Class.forName("com.mysql.jdbc.Driver");
  5.         conn = DriverManager.getConnection("url", "", "");
  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. }

5- 变量不合理的作用域

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

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

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

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

6- 改变哈希值

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

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

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

  1. /**
  2.  * 演示内存泄漏
  3.  * @create 14:43
  4.  */
  6. public class ChangeHashCode {
  7.     public static void main(String[] args) {
  8.         HashSet set = new HashSet();
  9.         Person p1 = new Person(1001, "AA");
  10.         Person p2 = new Person(1002, "BB");
  12.         set.add(p1);
  13.         set.add(p2);
  14.         p1.name = "CC";
  15.         set.remove(p1);
  16.         System.out.println(set);//2个对象！
  18. //        set.add(new Person(1001, "CC"));
  19. //        System.out.println(set);
  20. //        set.add(new Person(1001, "AA"));
  21. //        System.out.println(set);
  23.     }
  24. }
  26. class Person {
  27.     int id;
  28.     String name;
  30.     public Person(int id, String name) {
  31.         this.id = id;
  32.         this.name = name;
  33.     }
  35.     @Override
  36.     public boolean equals(Object o) {
  37.         if (this == o) return true;
  38.         if (!(o instanceof Person)) return false;
  40.         Person person = (Person) o;
  42.         if (id != person.id) return false;
  43.         return name != null ? name.equals(person.name) : person.name == null;
  44.     }
  46.     @Override
  47.     public int hashCode() {
  48.         int result = id;
  49.         result = 31 * result + (name != null ? name.hashCode() : 0);
  50.         return result;
  51.     }
  53.     @Override
  54.     public String toString() {
  55.         return "Person{" +
  56.                 "id=" + id +
  57.                 ", name='" + name + '\'' +
  58.                 '}';
  59.     }
  60. }
  1. /**
  2.  * 演示内存泄漏
  3.  * @create 14:47
  4.  */
  5. public class ChangeHashCode1 {
  6.     public static void main(String[] args) {
  7.         HashSet<Point> hs = new HashSet<Point>();
  8.         Point cc = new Point();
  9.         cc.setX(10);//hashCode = 41
  10.         hs.add(cc);
  11.         cc.setX(20);//hashCode = 51
  12.         System.out.println("hs.remove = " + hs.remove(cc));//false
  13.         hs.add(cc);
  14.         System.out.println("hs.size = " + hs.size());//size = 2
  15.     }
  16. }
  17. class Point {
  18.     int x;
  20.     public int getX() {
  21.         return x;
  22.     }
  24.     public void setX(int x) {
  25.         this.x = x;
  26.     }
  28.     @Override
  29.     public int hashCode() {
  30.         final int prime = 31;
  31.         int result = 1;
  32.         result = prime * result + x;
  33.         return result;
  34.     }
  36.     @Override
  37.     public boolean equals(Object obj) {
  38.         if (this == obj) return true;
  39.         if (obj == null) return false;
  40.         if (getClass() != obj.getClass()) return false;
  41.         Point other = (Point) obj;
  42.         if (x != other.x) return false;
  43.         return true;
  44.     }
  45. }

7- 缓存泄漏

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

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

  1. /**
  2.  * 演示内存泄漏
  3.  *
  4.  * @author shkstart
  5.  * @create 14:53
  6.  */
  7. public class MapTest {
  8.     static Map wMap = new WeakHashMap();
  9.     static Map map = new HashMap();
  11.     public static void main(String[] args) {
  12.         init();
  13.         testWeakHashMap();
  14.         testHashMap();
  15.     }
  17.     public static void init() {
  18.         String ref1 = new String("obejct1");
  19.         String ref2 = new String("obejct2");
  20.         String ref3 = new String("obejct3");
  21.         String ref4 = new String("obejct4");
  22.         wMap.put(ref1, "cacheObject1");
  23.         wMap.put(ref2, "cacheObject2");
  24.         map.put(ref3, "cacheObject3");
  25.         map.put(ref4, "cacheObject4");
  26.         System.out.println("String引用ref1，ref2，ref3，ref4 消失");
  28.     }
  30.     public static void testWeakHashMap() {
  32.         System.out.println("WeakHashMap GC之前");
  33.         for (Object o : wMap.entrySet()) {
  34.             System.out.println(o);
  35.         }
  36.         try {
  37.             System.gc();
  38.             TimeUnit.SECONDS.sleep(5);
  39.         } catch (InterruptedException e) {
  40.             e.printStackTrace();
  41.         }
  42.         System.out.println("WeakHashMap GC之后");
  43.         for (Object o : wMap.entrySet()) {
  44.             System.out.println(o);
  45.         }
  46.     }
  48.     public static void testHashMap() {
  49.         System.out.println("HashMap GC之前");
  50.         for (Object o : map.entrySet()) {
  51.             System.out.println(o);
  52.         }
  53.         try {
  54.             System.gc();
  55.             TimeUnit.SECONDS.sleep(5);
  56.         } catch (InterruptedException e) {
  57.             e.printStackTrace();
  58.         }
  59.         System.out.println("HashMap GC之后");
  60.         for (Object o : map.entrySet()) {
  61.             System.out.println(o);
  62.         }
  63.     }
  65. }
  66. /**
  67.  * 结果
  68.  * String引用ref1，ref2，ref3，ref4 消失
  69.  * WeakHashMap GC之前
  70.  * obejct2=cacheObject2
  71.  * obejct1=cacheObject1
  72.  * WeakHashMap GC之后
  73.  * HashMap GC之前
  74.  * obejct4=cacheObject4
  75.  * obejct3=cacheObject3
  76.  * Disconnected from the target VM, address: '127.0.0.1:51628', transport: 'socket'
  77.  * HashMap GC之后
  78.  * obejct4=cacheObject4
  79.  * obejct3=cacheObject3
  80.  **/

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

8- 监听器和回调

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

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