内存泄漏

一、概述

内存泄漏的主要问题可以分为以下几种类型：

• 静态变量引起的内存泄漏
• 非静态内部类引起的内存泄漏
• 资源未关闭引起的内存泄漏

二、静态变量引起的内存泄漏

在java中静态变量的生命周期是在类加载时开始，类卸载时结束。换句话说，在android中其生命周期是在进程启动时开始，进程死亡时结束。所以在程序的运行期间，如果进程没有被杀死，静态变量就会一直存在，不会被回收掉。如果静态变量强引用了某个Activity中变量，那么这个Activity就同样也不会被释放,即便是该Activity执行了onDestroy(不要将执行onDestroy和被回收划等号)。这类问题的解决方案为：1.寻找与该静态变量生命周期差不多的替代对象。2.若找不到，将强引用方式改成弱引用。比较典型的例子如下:

单例引起的Context内存泄漏

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class IMManager {    private Context context;    private static IMManager mInstance;      public static IMManager getInstance(Context context) {      if (mInstance == null ) {        synchronized (IMManager. class ) {          if (mInstance == null )            mInstance = new IMManager(context);        }      }      return mInstance;    }      private IMManager(Context context) {      this .context = context;    }   }

当调用getInstance时，如果传入的context是Activity的context。只要这个单例没有被释放，这个Activity也不会被释放。

解决方案 
传入Application的context,因为Application的context的生命周期比Activity长，可以理解为Application的context与单例的生命周期一样长，传入它是最合适的。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public class IMManager {    private Context context;    private static IMManager mInstance;      public static IMManager getInstance(Context context) {      if (mInstance == null ) {        synchronized (IMManager. class ) {          if (mInstance == null )            //将传入的context转换成Application的context            mInstance = new IMManager(context.getApplicationContext());        }      }      return mInstance;    }      private IMManager(Context context) {      this .context = context;    }   }

三、非静态内部类引起的内存泄漏

在java中，创建一个非静态的内部类实例，就会引用它的外围实例。如果这个非静态内部类实例做了一些耗时的操作，就会造成外围对象不会被回收，从而导致内存泄漏。这类问题的解决方案为：1.将内部类变成静态内部类 2.如果有强引用Activity中的属性，则将该属性的引用方式改为弱引用。3.在业务允许的情况下，当Activity执行onDestory时，结束这些耗时任务。

内部线程造成的内存泄漏

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

public class LeakAty extends Activity {      @Override    protected void onCreate(Bundle savedInstanceState) {      super .onCreate(savedInstanceState);      setContentView(R.layout.aty_leak);      test();    }      public void test() {      //匿名内部类会引用其外围实例LeakAty.this,所以会导致内存泄漏      new Thread( new Runnable() {          @Override        public void run() {          while ( true ) {            try {              Thread.sleep( 1000 );            } catch (InterruptedException e) {              e.printStackTrace();            }          }        }      }).start();    }    }

解决方案 
将非静态匿名内部类修改为静态匿名内部类

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public class LeakAty extends Activity {      @Override    protected void onCreate(Bundle savedInstanceState) {      super .onCreate(savedInstanceState);      setContentView(R.layout.aty_leak);      test();    }    //加上static，变成静态匿名内部类    public static void test() {      new Thread( new Runnable() {          @Override        public void run() {          while ( true ) {            try {              Thread.sleep( 1000 );            } catch (InterruptedException e) {              e.printStackTrace();            }          }        }      }).start();    } }

Handler引起的内存泄漏

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

public class LeakAty extends Activity {      @Override    protected void onCreate(Bundle savedInstanceState) {      super .onCreate(savedInstanceState);      setContentView(R.layout.aty_leak);      fetchData();      }      private Handler mHandler = new Handler() {      public void handleMessage(android.os.Message msg) {        switch (msg.what) {        case 0 :          // 刷新数据          break ;        default :          break ;        }        };    };      private void fetchData() {      //获取数据      mHandler.sendEmptyMessage( 0 );    } }

mHandler 为匿名内部类实例，会引用外围对象LeakAty.this,如果该Handler在Activity退出时依然还有消息需要处理，那么这个Activity就不会被回收。

解决方案

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

public class LeakAty extends Activity {    private TextView tvResult;    private MyHandler handler;      @Override    protected void onCreate(Bundle savedInstanceState) {      super .onCreate(savedInstanceState);      setContentView(R.layout.aty_leak);      tvResult = (TextView) findViewById(R.id.tvResult);      handler = new MyHandler( this );      fetchData();      }    //第一步，将Handler改成静态内部类。    private static class MyHandler extends Handler {      //第二步，将需要引用Activity的地方，改成弱引用。      private WeakReference<LeakAty> atyInstance;      public MyHandler(LeakAty aty) {        this .atyInstance = new WeakReference<LeakAty>(aty);      }        @Override      public void handleMessage(Message msg) {        super .handleMessage(msg);        LeakAty aty = atyInstance == null ? null : atyInstance.get();        //如果Activity被释放回收了，则不处理这些消息        if (aty == null ||aty.isFinishing()) {          return ;        }        aty.tvResult.setText( "fetch data success" );      }    }      private void fetchData() {      // 获取数据      handler.sendEmptyMessage( 0 );    }      @Override    protected void onDestroy() {      //第三步，在Activity退出的时候移除回调      super .onDestroy();      handler.removeCallbacksAndMessages( null );    } }

四、资源未关闭引起的内存泄漏

当使用了BraodcastReceiver、Cursor、Bitmap等资源时，当不需要使用时，需要及时释放掉，若没有释放，则会引起内存泄漏。

综上所述，内存泄漏的主要情况为上面的三大类型，最终归结为一点，就是资源在不需要的时候没有被释放掉。所以在编码的过程中要注意这些细节，提高程序的性能