解决Java内存泄露问题方案

内存泄漏的慨念

  1.c/c++是程序员自己治理内存,Java内存是由GC自动回收的。

  我虽然不是很熟悉C++,不过这个应该没有犯常识性错误吧。

  2.什么是内存泄露?

  内存泄露是指系统中存在无法回收的内存,有时候会造成内存不足或系统崩溃。

  在C/C++中分配了内存不释放的情况就是内存泄露。

  3.Java存在内存泄露

  我们必须先承认这个,才可以接着讨论。虽然Java存在内存泄露,但是基本上不用很关心它,非凡是那些对代码本身就不讲究的就更不要去关心这个了。

  Java中的内存泄露当然是指:存在无用但是垃圾回收器无法回收的对象。而且即使有内存泄露问题存在,也不一定会表现出来。

  4.Java中参数都是传值的。

  对于基本类型,大家基本上没有异议,但是对于引用类型我们也不能有异议。

  Java是如何管理内存

  为了判断Java中是否有内存泄露,我们首先必须了解Java是如何管理内存的。Java的内存管理就是对象的分配和释放问题。在Java中,程序员需要通过关键字new为每个对象申请内存空间 (基本类型除外),所有的对象都在堆 (Heap)中分配空间。另外,对象的释放是由GC决定和执行的。在Java中,内存的分配是由程序完成的,而内存的释放是有GC完成的,这种收支两条线的方法确实简化了程序员的工作。但同时,它也加重了JVM的工作。这也是Java程序运行速度较慢的原因之一。因为,GC为了能够正确释放对象,GC必须监控每一个对象的运行状态,包括对象的申请、引用、被引用、赋值等,GC都需要进行监控。

  监视对象状态是为了更加准确地、及时地释放对象,而释放对象的根本原则就是该对象不再被引用。

  为了更好理解GC的工作原理,我们可以将对象考虑为有向图的顶点,将引用关系考虑为图的有向边,有向边从引用者指向被引对象。另外,每个线程对象可以作为一个图的起始顶点,例如大多程序从main进程开始执行,那么该图就是以main进程顶点开始的一棵根树。在这个有向图中,根顶点可达的对象都是有效对象,GC将不回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意,该图为有向图),那么我们认为这个(这些)对象不再被引用,可以被GC回收。

  以下,我们举一个例子说明如何用有向图表示内存管理。对于程序的每一个时刻,我们都有一个有向图表示JVM的内存分配情况。以下图二,就是图一程序运行到第6行的示意图。

*图一
class test{
Public static void main{string(a[]){
       object o1=newobject();
       object o2=newobject();
       o2=o1;
       /此行为第六行
            }
}

*图二
main进程 --o1 -- object1
         --o2 -- object1
                  objiect2
(该图为描述了第六行内存管理的有向图,Obj2为第二次申请的对象,此时为可回收对象)

  Java使用有向图的方式进行内存管理,可以消除引用循环的问题,例如有三个对象,相互引用,只要它们和根进程不可达的,那么GC也是可以回收它们的。这种方式的优点是管理内存的精度很高,但是效率较低。另外一种常用的内存管理技术是使用计数器,例如COM模型采用计数器方式管理构件,它与有向图相比,精度行低(很难处理循环引用的问题),但执行效率很高。

  Java内存泄露情况

  JVM回收算法是很复杂的,我也不知道他们怎么实现的,但是我只知道他们要实现的就是:对于没有被引用的对象是可以回收的。所以你要造成内存泄露就要做到:

  持有对无用对象的引用!

  不要以为这个很轻易做到,既然无用,你怎么还会持有它的引用? 既然你还持有它,它怎么会是无用的呢?

  我实在想不到比那个堆栈更经典的例子了,以致于我还要引用别人的例子,下面的例子不是我想到的,是书上看到的,当然假如没有在书上看到,可能过一段时间我自己也想的到,可是那时我说是我自己想到的也没有人相信的。

  public class Stack {

  private Object[] elements=new Object[10];

  private int size = 0;

  public void push(Object e){

  ensureCapacity();

  elements[size++] = e;

  }

  public Object pop(){

  if( size == 0)

  throw new EmptyStackException();

  return elements[--size];

  }

  private void ensureCapacity(){

  if(elements.length == size){

  Object[] oldElements = elements;

  elements = new Object[2 * elements.length+1];

  System.arraycopy(oldElements,0, elements, 0, size);

  }

  }

  }

上面的原理应该很简单,假如堆栈加了10个元素,然后全部弹出来,虽然堆栈是空的,没有我们要的东西,但是这是个对象是无法回收的,这个才符合了内存泄露的两个条件:无用,无法回收。

  但是就是存在这样的东西也不一定会导致什么样的后果,假如这个堆栈用的比较少,也就浪费了几个K内存而已,反正我们的内存都上G了,哪里会有什么影响,再说这个东西很快就会被回收的,有什么关系。下面看两个例子。

  例子1

  public class Bad{

  public static Stack s=Stack();

  static{

  s.push(new Object());

  s.pop(); //这里有一个对象发生内存泄露

  s.push(new Object()); //上面的对象可以被回收了,等于是自愈了

  }

  }

  因为是static,就一直存在到程序退出,但是我们也可以看到它有自愈功能,就是说假如你的Stack最多有100个对象,那么最多也就只有100个对象无法被回收其实这个应该很轻易理解,Stack内部持有100个引用,最坏的情况就是他们都是无用的,因为我们一旦放新的进取,以前的引用自然消失!

  例子2

  public class NotTooBad{

  public void doSomething(){

  Stack s=new Stack();

  s.push(new Object());

  //other code

  s.pop();//这里同样导致对象无法回收,内存泄露.

  }//退出方法,s自动无效,s可以被回收,Stack内部的引用自然没了,所以

  //这里也可以自愈,而且可以说这个方法不存在内存泄露问题,不过是晚一点

  //交给GC而已,因为它是封闭的,对外不开放,可以说上面的代码99.9999%的

  //情况是不会造成任何影响的,当然你写这样的代码不会有什么坏的影响,但是

  //绝对可以说是垃圾代码!没有矛盾吧,我在里面加一个空的for循环也不会有

  //什么太大的影响吧,你会这么做吗?

  }

  上面两个例子都不过是小打小闹,但是C/C++中的内存泄露就不是Bad了,而是Worst了。他们假如一处没有回收就永远无法回收,频繁的调用这个方法内存不就用光了!因为Java还有自愈功能(我自己起的名字,还没申请专利),所以Java的内存泄露问题几乎可以忽略了,但是知道的人就不要犯了。

  不知者无罪!Java存在内存泄露,但是也不要夸大其辞。假如你对Java都不是很熟,你根本就不用关心这个,我说过你无意中写出内存泄露的例子就像你中一千万一样概率小,开玩笑了,其实应该是小的多的多!

  而且即使你有幸写出这样的代码,中奖了!基本上都是一包洗衣粉,不会让你发财,对系统没有什么大的影响。

  杞人忧天的情况

  1.无话可说型

  Object obj=new Object();

  obj=null;

  //这个完全多此一举,因为退出了作用范围,对象的引用自动消失

  //不要在你的程序中出现这样的语句,没有错,但是就是不雅观

  2.思考不对型

  void func(Object o){

  o=new Object();

  return

  }

  当我们知道Java参数是传值,就知道上面的方法什么也没错,就是申请了一个对象然后再丢给GC。因为是传值,这里的o是一个调用时候的拷贝,会不会无法回收?不就是拷贝吗,退出方法什么都没了,这个对象怎么会留的住。

3.尽量避免型

  class A{

  B b=new B(this);

  }

  class B{

  A a;

  B(A a){this.a=a;}

  }

  这个存在互相引用,可能导致孤岛现象,但是这个不会造成内存泄露不过我自己觉得这个会降低GC的效率,就从我的智力来看,我觉得这种情况比一般情况难以判定怎么回收!当然GC比我聪明,不过应该也要动一点脑子吧。

  在把组件提交到集成阶段之前,每个开发人员必须对他们的组件进行性能单元测试。传统的单元测试仅仅重视功能而忽略性能。

  在单元测试期间,性能单元测试意味着需要用以下的工具分析组件:

  Memory profiler

  Code profiler

  Coverage profiler

  Memory profiler 在用例开始前和在用例结束后运行垃圾回收并且记录堆的快照。从这些数据中,我们能看到用例的内存影响及该用例在内存中留下的具体对象列表。开发人员需要检查那些对象以确认在用例执行完成后那些对象就应该保留在内存中。当用例完成后,如果对象被疏忽而留在堆中,那么这就是Java内存泄漏,并且我们这些称为游离对象,有时也可称为遗留对象引用。

  下一个需要寻找的内存问题称为对象循环。在用例执行期间,所记录的细粒度的堆的采样信息,结合创建和删除的数量,说明了对象被创建和删除的次数。如果对象被迅速地创建并删除,那么它将给JVM带来非常大的压力。每个被创建及删除的对象仅能由垃圾搜集回收,并且对象循环显着地增加垃圾回收的频率。这种情况通常发生在一个循环或嵌套循环内部的对象创建的情况。

  让我们看看以下的代码:

  for( int i=0; i<object.size(); i++ ) {

  for( int j=0; j<object2.size(); j++ ) {

  int threshold = system.getThreshold();

  if( object[i].getThing() - object2[j].getOtherThing() > threshold ) {

  // Do something

  }

  }

  }

  在这个例子中,外部循环遍历object中的所有项目,并且每个项目都遍历object2的所有项目。如果object包含1000个项目并且 object2也包含了1000个项目,那么被定义在循环内部的代码将被执行1000 *1000次,或1百万次。在这种代码下,阈限变量将每次在内部循环运行时(当该对象的引用超出作用域范围时对象将被销毁) 被分配和销毁。如果你在Memory profiler里看到这个代码,你将看到一百万个阈限实例被创建并被销毁。

  代码应该用如下的方式重写来消除这种情况:

  int threshold = system.getThreshold();

  int threshold = system.getThreshold();

  for( int j=0; j<object2.size(); j++ ) {

  if( object[i].getThing() - object2[j].getOtherThing() > threshold ) {

  // Do something

  }

  }

  }

  现在,对与一百万次循环,阈限变量只分配一次。阈限变量的影响从至关重要变为微不足道。

  在基于Web应用中,我们经常看到的关于对象循环的场景是在在请求的上下文中创建对象。在单次使用情况下,这并不是问题,不过一但当用户的负载显着增加时,这个问题就很快变得很明显。你必须做出的决定是,这个对象是否需要基于每个请求创建,或者如果一旦它被创建,那么可被缓冲以被随后的请求重用。如果对这个问题的回答是后者,那么你可以消除该对象的循环使用问题。图1显示当对象循环发生时堆的视图。

  eclipse 有启动参数里设置jvm大小,因为eclipse运行时自己也需要jvm,所以eclipse.ini里设置的jvm大小不是具体某个程序运行时所用jvm的大小,这和具体程序运行的jvm大小无关。

  那么怎么才能设置某个程序的jvm大小呢(当然控制台运行的话不会存在这个问题,如:java -Xms256m -Xmx1024m classname,这样就可以把当前程序的jvm大小给设定)?

  因为eclipse里默认的一个程序的jvm配置为:-Xms8m -Xmx128m,所以我们的处理耗内存比较大时需要手动调整一下,以便不会内存溢出。具体的设置方法为:

  选中被运行的类,点击菜单‘Run->Run Configurations...’,选择(x)=Argument标签页下的vm arguments框里输入 -Xmx512m, 保存运行就ok了.

  我经常处理大的浮点矩阵,所以我用的是 -Xmx1024m

添加新评论