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的引用。