Android 后台任务（七）内存泄露

Android 后台任务（七）内存泄露

翻译自：http://www.androiddesignpatterns.com/2013/01/inner-class-handler-memory-leak.html

转载请注明：http://blog.csdn.net/liaoqianchuan00/article/details/23953893

 考虑下面的代码：

 

public class SampleActivity extends Activity {

privatefinal Handler mLeakyHandler = new Handler() {

     @Override

     public void handleMessage(Message msg) {

       // ...

      }

   }

}

 

虽然不明显，但是这段代码可能导致内存泄露。Android Lint会提示以下信息：

 

In Android, Handler classes should be static or leaksmight occur.

 

但是哪里有内存泄露，是怎么出现的呢？首先我们来了解下这些信息：

 

1.       当一个Android应用程序启动的时候，Anroid框架为这个程序的主线程即UI线程创建了一个Looper对象。Looper实现了一个简单的messagequeue，不断循环的处理其中的message。所有的应用程序框架的事件（比如Activity生命周期的调用，按钮的点击等）都被封装在这个Message对象里，然后被加入到Looper的Messagequeue，最后一个一个的处理这些Message。Looper在整个应用程序的生命周期中一直存在。

 

2.       当我们在主线程中实例化一个Handler对象的时候，和他关联了主线程的Looper的Messagequeue。被发送到这个Message queue的Message都保持了一个Handler对象的引用，这样框架就可以在处理这个Message的时候调用Handler.handleMessage(Message)来处理消息了。

 

3.       在Java中，非静态内部类和匿名内部类都隐式的保持了一个outerclass的引用。但是静态内部类不会有这个引用。

 

 

那么内存泄露到底在哪里呢？很难发现吧，让我们接着看下面的例子：

 

public class MainActivity extends Activity {

 

  private finalHandler mLeakyHandler = new Handler() {

    @Override

    public voidhandleMessage(Message msg) {

      // ...

    }

  };

 

  @Override

  protectedvoid onCreate(Bundle savedInstanceState) {

   super.onCreate(savedInstanceState);

 

    // Post amessage and delay its execution for 10 minutes.

   mLeakyHandler.postDelayed(new Runnable() {

      @Override

      publicvoid run() { }

    }, 60 * 10* 1000);

 

    // Go backto the previous Activity.

    finish();

  }

}

 

当Activity finished的时候，需要延迟处理的message将会继续存在于主线程的Message queue中10分钟。这个Message保持了一个对Activity中Handler的引用，Handler又保持了一个对outer class（这个例子中的MainActivity）的引用。这些引用在Message被处理完之前会一直存在，这就导致了Activity context不会被GC回收掉，导致程序的resources泄露。需要注意的是泄露同样发生在匿名的runnable类中，非静态的匿名类也保持了一个对outer class的引用，也会导致context 泄露。

 

要解决这个问题，可以在另外一个文件中生成一个Handler的子类或者用静态内部类来替代之前的内部类。静态的内部类不会保持对outer class的引用，所以activity不会泄露。如果你需要在Handler中访问外部activity的方法，可以在Handler中保持一个对Activity的WeakReference，这样就不会发生context leak。要解决匿名Runnable 类的泄露，我们可以让使用静态的成员变量（静态的匿名类实例也不会保持对outer class的引用）。

 

public class MainActivity extends Activity {

 

  /**

   * Instancesof static inner classes do not hold an implicit

   * referenceto their outer class.

   */

  privatestatic class MyHandler extends Handler {

    privatefinal WeakReference<MainActivity> mActivity;

 

    publicMyHandler(MainActivity activity) {

      mActivity= new WeakReference<MainActivity>(activity);

    }

 

    @Override

    public voidhandleMessage(Message msg) {

          MainActivity activity = mActivity.get();

      if(activity != null) {

        // ...

      }

    }

  }

 

  private finalMyHandler mHandler = new MyHandler(this);

 

  /**

   * Instancesof anonymous classes do not hold an implicit

   * referenceto their outer class when they are "static".

   */

  privatestatic final Runnable sRunnable = new Runnable() {

      @Override

      publicvoid run() { }

  };

 

  @Override

  protectedvoid onCreate(Bundle savedInstanceState) {

   super.onCreate(savedInstanceState);

 

    // Post amessage and delay its execution for 10 minutes.

   mHandler.postDelayed(sRunnable, 60 * 10 * 1000);

   

    // Go backto the previous Activity.

    finish();

  }

}

 

静态内部类和非静态内部类的区别很微小，但是我们开发人员必须了解。那么底线是什么？当内部类可以独立于Activity的生命周期而存在的时候，我们应该避免使用非静态的内部类，应该用静态内部类并且使用WeakReference保持对Activity的引用。