前置知识
内存泄漏（memory leak）
可达性分析算法来判断对象是否是不再使用的对象，本质都是判断一个对象是否还被引用。那么对于这种情况下，由于代码的实现不同就会出现很多种内存泄漏问题（让JVM误以为此对象还在引用中，无法回收，造成内存泄漏）。
＞ 是否还被使用？是
＞ 是否还被需要？否
严格来说，只有对象不会再被程序用到了，但是GC又不能回收他们的情况，才叫内存泄漏。但实际情况很多时候一些不太好的实践（或疏忽）会导致对象的生命周期变得很长甚至导致00M，也可以叫做宽泛意义上的“内存泄漏”。
如下图，当Y生命周期结束的时候，X依然引用着Y，这时候，垃圾回收期是不会回收对象Y的；如果对象X还引用着生命周期比较短的A、B、C，对象A又引用着对象 a、b、c，这样就可能造成大量无用的对象不能被回收，进而占据了内存资源，造成内存泄漏，直到内存溢出。
申请了内存用完了不释放，比如一共有1024M的内存，分配了512M的内存一直不回收，那么可以用的内存只有512M了，仿佛泄露掉了一部分。
内存溢出（out of memory）
申请内存时，没有足够的内存可以使用；通俗一点儿讲，一个厕所就三个坑，有两个站着茅坑不走的（内存泄漏），剩下最后一个坑，厕所表示接待压力很大，这时候一下子来了两个人，坑位（内存）就不够了，内存泄漏变成内存溢出了。可见，内存泄漏和内存溢出的关系：内存泄漏的增多，最终会导致内存溢出。
泄漏的分类
- 经常发生：发生内存泄露的代码会被多次执行，每次执行，泄露一块内存；
- 偶然发生：在某些特定情况下才会发生
- 一次性：发生内存泄露的方法只会执行一次；
- 隐式泄漏：一直占着内存不释放，直到执行结束；严格的说这个不算内存泄漏，因为最终释放掉了，但是如果执行时间特别长，也可能会导致内存耗尽。
Java中内存泄露的8种情况
静态集合类
静态集合类，如HashMap、LinkedList等等。如果这些容器为静态的，那么它们的生命周期与JVM程序一致，则容器中的对象在程序结束之前将不能被释放，从而造成内存泄漏。简单而言，长生命周期的对象持有短生命周期对象的引用，尽管短生命周期的对象不再使用，但是因为长生命周期对象持有它的引用而导致不能被回收。
1. public class MemoryLeak { 2. static List list = new ArrayList(); 3. public void oomTests(){ 4. Object obj＝new Object();//局部变量 5. list.add(obj); 6. } 7. }
单例模式
单例模式，和静态集合导致内存泄露的原因类似，因为单例的静态特性，它的生命周期和 JVM 的生命周期一样长，所以如果单例对象如果持有外部对象的引用，那么这个外部对象也不会被回收，那么就会造成内存泄漏。
内部类持有外部类
内部类持有外部类，如果一个外部类的实例对象的方法返回了一个内部类的实例对象。这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持有外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄漏。
各种连接，如数据库连接、网络连接和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）{//异常日志 9. } finally { 10. // 1．关闭结果集 Statement 11. // 2．关闭声明的对象 ResultSet 12. // 3．关闭连接 Connection 13. } 14. }
变量不合理的作用域
变量不合理的作用域。一般而言，一个变量的定义的作用范围大于其使用范围，很有可能会造成内存泄漏。另一方面，如果没有及时地把对象设置为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的内存空间。
改变哈希值
改变哈希值，当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了。
否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄漏。
这也是 String 为什么被设置成了不可变类型，我们可以放心地把 String 存入 HashSet，或者把String 当做 HashMap 的 key 值；当我们想把自己定义的类保存到散列表的时候，需要保证对象的 hashCode 不可变。
1. public class ChangeHashCode { 2. public static void main(String[] args) { 3. HashSet set = new HashSet(); 4. Person p1 = new Person(1001, "AA"); 5. Person p2 = new Person(1002, "BB"); 6. 7. set.add(p1); 8. set.add(p2); 9. 10. p1.name = "CC";//导致了内存的泄漏 11. set.remove(p1); //删除失败 12. 13. System.out.println(set); 14. 15. set.add(new Person(1001, "CC")); 16. System.out.println(set); 17. 18. set.add(new Person(1001, "AA")); 19. System.out.println(set); 20. 21. } 22. } 23. 24. class Person { 25. int id; 26. String name; 27. 28. public Person(int id, String name) { 29. this.id = id; 30. this.name = name; 31. } 32. 33. @Override 34. public boolean equals(Object o) { 35. if (this == o) return true; 36. if (!(o instanceof Person)) return false; 37. 38. Person person = (Person) o; 39. 40. if (id != person.id) return false; 41. return name != null ? name.equals(person.name) : person.name == null; 42. } 43. 44. @Override 45. public int hashCode() { 46. int result = id; 47. result = 31 * result + (name != null ? name.hashCode() : 0); 48. return result; 49. } 50. 51. @Override 52. public String toString() { 53. return "Person{" + 54. "id=" + id + 55. ", name='" + name + '\'' + 56. '}'; 57. } 58. }
1. /** 2. * 例2 3. */ 4. public class ChangeHashCode1 { 5. public static void main(String[] args) { 6. HashSet<Point> hs = new HashSet<Point>(); 7. Point cc = new Point(); 8. cc.setX(10);//hashCode = 41 9. hs.add(cc); 10. 11. cc.setX(20);//hashCode = 51 此行为导致了内存的泄漏 12. 13. System.out.println("hs.remove = " + hs.remove(cc));//false 14. hs.add(cc); 15. System.out.println("hs.size = " + hs.size());//size = 2 16. 17. System.out.println(hs); 18. } 19. 20. } 21. 22. class Point { 23. int x; 24. 25. public int getX() { 26. return x; 27. } 28. 29. public void setX(int x) { 30. this.x = x; 31. } 32. 33. @Override 34. public int hashCode() { 35. final int prime = 31; 36. int result = 1; 37. result = prime * result + x; 38. return result; 39. } 40. 41. @Override 42. public boolean equals(Object obj) { 43. if (this == obj) return true; 44. if (obj == null) return false; 45. if (getClass() != obj.getClass()) return false; 46. Point other = (Point) obj; 47. if (x != other.x) return false; 48. return true; 49. } 50. 51. @Override 52. public String toString() { 53. return "Point{" + 54. "x=" + x + 55. '}'; 56. } 57. }
缓存泄露
内存泄漏的另一个常见来源是缓存，一旦你把对象引用放入到缓存中，他就很容易遗忘。比如：之前项目在一次上线的时候，应用启动奇慢直到夯死，就是因为代码中会加载一个表中的数据到缓存（内存）中，测试环境只有几百条数据，但是生产环境有几百万的数据。
对于这个问题，可以使用WeakHashMap代表缓存，此种Map的特点是，当除了自身有对key的引用外，此key没有其他引用那么此map会自动丢弃此值。
1. public class MapTest { 2. static Map wMap = new WeakHashMap(); 3. static Map map = new HashMap(); 4. 5. public static void main(String[] args) { 6. init(); 7. testWeakHashMap(); 8. testHashMap(); 9. } 10. 11. public static void init() { 12. String ref1 = new String("obejct1"); 13. String ref2 = new String("obejct2"); 14. String ref3 = new String("obejct3"); 15. String ref4 = new String("obejct4"); 16. wMap.put(ref1, "cacheObject1"); 17. wMap.put(ref2, "cacheObject2"); 18. map.put(ref3, "cacheObject3"); 19. map.put(ref4, "cacheObject4"); 20. System.out.println("String引用ref1，ref2，ref3，ref4 消失"); 21. 22. } 23. 24. public static void testWeakHashMap() { 25. System.out.println("WeakHashMap GC之前"); 26. for (Object o : wMap.entrySet()) { 27. System.out.println(o); 28. } 29. try { 30. System.gc(); 31. TimeUnit.SECONDS.sleep(5); 32. } catch (InterruptedException e) { 33. e.printStackTrace(); 34. } 35. System.out.println("WeakHashMap GC之后"); 36. for (Object o : wMap.entrySet()) { 37. System.out.println(o); 38. } 39. } 40. 41. public static void testHashMap() { 42. System.out.println("HashMap GC之前"); 43. for (Object o : map.entrySet()) { 44. System.out.println(o); 45. } 46. try { 47. System.gc(); 48. TimeUnit.SECONDS.sleep(5); 49. } catch (InterruptedException e) { 50. e.printStackTrace(); 51. } 52. System.out.println("HashMap GC之后"); 53. for (Object o : map.entrySet()) { 54. System.out.println(o); 55. } 56. } 57. 58. }
上面代码和图示主演演示WeakHashMap如何自动释放缓存对象，当init函数执行完成后，局部变量字符串引用weakd1，weakd2，d1，d2都会消失，此时只有静态map中保存中对字符串对象的引用，可以看到，调用gc之后，HashMap的没有被回收，而WeakHashMap里面的缓存被回收了。
监听器和其他回调
内存泄漏第三个常见来源是监听器和其他回调，如果客户端在你实现的API中注册回调，却没有显示的取消，那么就会积聚。需要确保回调立即被当作垃圾回收的最佳方法是只保存它的弱引用，例如将他们保存成为WeakHashMap中的键。
