内存泄露：Handler是如何造成内存泄露的

先看下面这段handler代码：

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

在使用handler时，这是一段很常见的代码。但是，它却会造成严重的内存泄漏问题。上述代码的编写往往会得到如下警告：

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

那么，handler是如何造成内存泄漏的呢？

分析

1、 Android角度

当Android应用程序启动时，framework会为该应用程序的主线程创建一个Looper对象。这个Looper对象包含一个简单的消息队列Message Queue，并且能够循环的处理队列中的消息。这些消息包括大多数应用程序framework事件，例如Activity生命周期方法调用、button点击等，这些消息都会被添加到消息队列中并被逐个处理。主线程的Looper对象会伴随该应用程序的整个生命周期。

当主线程里，实例化一个Handler对象后，它就会自动与主线程Looper的消息队列关联起来。所有发送到消息队列的消息Message都会拥有一个对Handler的引用，所以当Looper来处理消息时，会据此回调Handler#handleMessage(Message)方法来处理消息。

2、 Java角度

在java里，非静态内部类和匿名类都会潜在的引用它们所属的外部类。但是，静态内部类却不会。

原因是java在生成内部类的时候，原本没有构造器的内部类会被生成一个带外部类参数的构造器，就是因为这个内部类才持有了外部类的隐式引用。

很直观的方法就是看.class 文件的大小, 有非静态内部类的.class文件，比静态内部类的文件大出很多.

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结束(finish)时，在里面的延时消息在得到处理前，会一直保存在主线程的消息队列里持续10分钟。而且，由上文可知，这条消息持有对handler的引用，而handler又持有对其外部类（即SampleActivity）的潜在引用。这条引用关系会一直保持直到消息得到处理。这阻止了SampleActivity被垃圾回收器回收，同时造成程序内存的泄漏。

而且需要注意的是，上面代码中的Runnable类（非静态匿名类）同样持有对其外部类的引用。从而也导致泄漏。

总结一下：

1. 只要有未处理的消息，那么消息会引用handler，非静态的handler又会引用外部类Activity，这导致Activity无法被回收，造成泄漏；
2. Runnable类属于非静态匿名类，同样会引用外部类。

解决方式：
把handler类放在单独的类文件中，或者使用静态内部类。对于匿名类Runnable，同样可以将其设置为静态类。

如果想要在handler内部去调用所在的外部类Activity，那么可以在handler内部使用弱引用的方式指向所在Activity。

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 previous Activity.
   finish();
 }
}

小结
虽然静态类与非静态类之间的区别并不大，但是对于Android开发者而言却是必须理解的。至少要清楚，如果一个内部类实例的生命周期比Activity更长，那么我们千万不要使用非静态的内部类。最好的做法是，使用静态内部类，然后在该类里使用弱引用来指向所在的Activity。

问题一：什么情形下，handler持有的activity引用为null被回收了？
问题二：如果activity引用被回收了，应该怎么处理？