Handle & Inner Classes 如何避免内存泄漏

查看下面一段代码

public class SampleActivity extends Activity {  private final Handler mLeakyHandler = new Handler() {    @Override    public void handleMessage(Message msg) {      // ...     }  };}

上面一段代码看起来很正常，但这段代码确实能造成大量的内存泄漏。并且，Android Lint(Android studio 编译器的提示) 将会给你下面的警告：

In Android, Handler classes should be static or leaks might occur.

但泄漏到底在哪里，何时发生? 我们就可以用我们所知道的来确定问题的根源：

1.Android 应用程序首次启动时，framework将会为application’s main thread 创建一个looper对象。looper实现了一个简单的message队列,循环的处理message对象。所有的主要application framework事件（例如 activity生命周期方法的调用， button的点击事件, 等等） 都包含在Message对象中，message 被添加到looper的message队列中并且逐个处理。

2.当一个handler在main thread中实例化，它将会和looper’s 消息队列关联。当handler发送一个message到消息队列中，该message对象将会持有handler的引用. 所以,当looper处理该消息的时候，framework 可以调用handler#handler（message）方法

3.在Java中，非静态内部和匿名类保留对其外部类的隐含引用。但是，静态内部类将不会。

那么内存泄漏究竟在哪里呢？这很微妙，我们以下面的代码为例：

public class SampleActivity extends Activity {  private final Handler mLeakyHandler = new Handler() {    @Override    public void handleMessage(Message msg) {      // ...    }  };  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    // Post a message and delay its execution for 10 minutes.    mLeakyHandler.postDelayed(new Runnable() {      @Override      public void run() { /* ... */ }    }, 1000 * 60 * 10);    // Go back to the previous Activity.    finish();  }}

当这个activity被销毁，延迟消息在被处理之前会继续在主线程的队列中存活10分钟。消息对象将会持有handler引用，而且handler也持有一个隐含的引用外部类（在这个例子中是SampleActivity）。这个引用直到消息被处理之前将一直保留。注意，在匿名 Runnable 类中的15行也是如此。非静态的匿名类实例持有一个他们的外部类的隐含引用，所以，context将会泄漏。

要解决这个问题，需要将继承handler的子类创建成一个新的文件， 或者使用静态内部类来代替。静态内部类不会持有他们的外部类的隐含引用，所以，activity将不会泄漏。如果你需要在handler内部调用外部activity的方法，可以在handler持有一个WeakReference 的activity，那么你讲不会意外地泄漏context。为了修复当我们实例化一个匿名Runnable 类时发生的内存泄漏，我们使变量成为该类的一个静态字段（由于匿名类的静态实例不包含对外部类的隐含引用）：

public class SampleActivity extends Activity {  /**   * Instances of static inner classes do not hold an implicit   * reference to their outer class.   */  private static class MyHandler extends Handler {    private final WeakReference<SampleActivity> mActivity;    public MyHandler(SampleActivity activity) {      mActivity = new WeakReference<SampleActivity>(activity);    }    @Override    public void handleMessage(Message msg) {      SampleActivity activity = mActivity.get();      if (activity != null) {        // ...      }    }  }  private final MyHandler mHandler = new MyHandler(this);  /**   * Instances of anonymous classes do not hold an implicit   * reference to their outer class when they are "static".   */  private static final Runnable sRunnable = new Runnable() {      @Override      public void run() { /* ... */ }  };  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    // Post a message and delay its execution for 10 minutes.    mHandler.postDelayed(sRunnable, 1000 * 60 * 10);    // Go back to the pevious Activity.    finish();  }}

静态类和非静态类的区别是微妙的，但是，这是每一个android开发人员需要知道的。
最关键的是什么？如果一个内部类能够存活的比activity的生命周期还长，应该避免在activity使用非静态内部类。因此，宁可选择静态内部类并在里面持有一个弱引用的activity。

原文链接：http://www.androiddesignpatterns.com/2013/01/inner-class-handler-memory-leak.html