Android中由Handler和内部类引起的内存泄漏

原文地址：http://johnnyshieh.github.io/android/2015/09/03/android-handler-memory-leak/

在Android中我们经常用Handler来处理异步消息，把非主线程的操作结果放在主线程中更新UI。请思考一下下面的代码有没有问题：

public class SampleActivity extends Activity {

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

虽然看起来好像没什么问题，但是这段代码可能引起内存泄露。Android Lint工具会给出以下警告：

In Android, Handler classes should be static or leaks might occur, Messages enqueued on the application thread’s MessageQueue also retain their target Handler. If the Handler is an inner class, its outer class will be retained as well. To avoid leaking the outer class, declare the Handler as a static nested class with a WeakReference to its outer class

但是什么东西泄漏了，内存泄漏怎么发生的我们还是不清楚。接下来我们慢慢分析泄漏的原因：

1. 当一个Android应用启动时，框架会分配到一个Looper实例给应用的主线程。这个Looper的主要工作就是处理一个接着一个的消息对象。在Android中，所有Android框架的事件（比如Activity的生命周期方法的调用和按钮的点击等）都是放到消息中，然后加入到Looper要处理的消息队列中，由Looper依次处理。主线程的Looper的生命周期和应用的一样长。

2. 当在主线程中初始化一个Handler时，它就会关联到Looper的消息队列。发送到消息队列的消息本身就持有Handler的引用，只有这样Looper在处理这个条消息的时候才能调用Handler#handleMessage(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();
    }
}

注意上面的匿名Runnable类也隐式地持有SampleActivity的引用，这也会阻止context被回收。当Activity是finished的时候，被延迟的消息在被处理之前依然会存活在主线程的消息队列中10分钟。这个消息持有Activity的Handler的引用，而Handler隐式地持有其外部类（SampleActivity）的引用。这些引用会一直保持直到消息被处理完成，而这会导致Activity无法被垃圾回收器回收并且泄漏应用的所有资源，因此就产生了内存泄漏。

要解决这个问题，在继承Handler的时候要么放在一个单独的类文件中，要么用静态内部类替代。因为静态内部类不会持有其外部类的隐式引用，所以不会产生contex泄漏。如果要在Handler中调用外部Activity的方法，可以持有Activity的弱引用。同样的道理，要解决匿名Runanable类引起的内存泄漏，只需要把它设为静态的成员属性（静态的匿名内部类不会持有其外部类的隐式引用）。

修改后的代码如下：

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();
    }
}

原文链接：How to Leak a Context: Handlers & Inner Classes 作者：Alex Lockwood静态内部类和非静态内部类的区别是我们每一个Android开发人员应该掌握的。当内部类的实例的生命周期可能大于Activity的生命周期时，避免使用非静态的内部类。个人更倾向于用静态内部类或持有Activity的弱引用。