您的位置: 首页  >  文章  >  浅析Handler引起的内存泄漏及解决方法

浅析Handler引起的内存泄漏及解决方法

分类: 文章 • 2023-11-27 23:08:28
在进行异步操作时，我们经常会使用到Handler类。最常见的写法如下。
[java] view plain copy
  1. public class MainActivity extends Activity {  
  2.     ......  
  3.   
  4.     private Handler mHandler = new Handler() {  
  5.         @Override  
  6.         public void handleMessage(Message msg) {  
  7.             // your code  
  8.         }  
  9.     };  
  10. }  

但是，这段代码有可能会引起内存泄漏。我们来分析一下内存泄漏是如何发生的。

当使用内部类或匿名内部类的方式创建Handler时，Handler对象会隐式地持有一个外部类对象的引用（这里的外部类是Activity）。

一般在一个耗时任务中会开启一个子线程，如网络请求或文件读写操作，我们会使用到Handler对象。但是，如果在任务未执行完时，Activity被关闭了，Activity已不再使用，此时由GC来回收掉Activity对象。由于子线程未执行完毕，子线程持有Handler的引用，而Handler又持有Activity的引用，这样直接导致Activity对象无法被GC回收，即出现内存泄漏。


下面用一段代码示例来说明。
[java] view plain copy
  1. public class MainActivity extends Activity {  
  2.     ......  
  3.   
  4.     @Override  
  5.     protected void onCreate(Bundle savedInstanceState) {  
  6.         super.onCreate(savedInstanceState);  
  7.         ......  
  8.   
  9.         new Thread(new Runnable() {  
  10.             @Override  
  11.             public void run() {  
  12.                 HttpUtils.downloadFile(url);  
  13.                 mHandler.sendEmptyMessage(MSG_SUCCESS);  
  14.             }  
  15.         }).start();  
  16.     }  
  17.   
  18.     private Handler mHandler = new Handler() {  
  19.         @Override  
  20.         public void handleMessage(Message msg) {  
  21.             if (msg.what == MSG_SUCCESS) {  
  22.                 // your code  
  23.             }  
  24.         }  
  25.     };  
  26. }  
在MainActivity启动时，开启一个子线程来下载文件。如果文件较大或网络不稳定的因素，导致短时间内无法执行完成，用户按下返回键退出了当前界面。此时子线程仍然在运行，并持有mHandler的引用，而mHandler是一个匿名内部类的对象，持有MainActivity的引用，这样MainActivity对象无法被回收，MainActivity内部的很多资源都无法被回收。

对于这个问题，来自Android Framework的工程师Romain Guy在google groups上给出了解释和建议。
链接：
https://groups.google.com/forum/?fromgroups=#%21msg/android-developers/1aPZXZG6kWk/lIYDavGYn5UJ
截图：
浅析Handler引起的内存泄漏及解决方法

另外，在androiddesignpatterns上也有人给出了解决方案：
http://www.androiddesignpatterns.com/2013/01/inner-class-handler-memory-leak.html

解决方法主要在于两点：
1.将Handler声明为静态内部类。因为静态内部类不会持有外部类的引用，所以不会导致外部类实例出现内存泄露。
2.在Handler中添加对外部Activity的弱引用。由于Handler被声明为静态内部类，不再持有外部类对象的引用，导致无法在handleMessage()中操作Activity中的对象，所以需要在Handler中增加一个对Activity的弱引用。

改善之后的代码如下。
[java] view plain copy
  1. public class MainActivity extends Activity {  
  2.     ......  
  3.   
  4.     private final MyHandler mHandler = new MyHandler(this);  
  5.   
  6.     private static class MyHandler extends Handler {  
  7.         private final WeakReference<MainActivity> mActivity;  
  8.   
  9.         public MyHandler(MainActivity activity) {  
  10.             this.mActivity = new WeakReference<MainActivity>(activity);  
  11.         }  
  12.   
  13.         @Override  
  14.         public void handleMessage(Message msg) {  
  15.             MainActivity mainActivity = mActivity.get();  
  16.             if (mainActivity == null) {  
  17.                 return;  
  18.             }  
  19.             // your code here  
  20.         }  
  21.     }  
  22. }  

关于WeakReference的说明：

WeakReference即弱引用，与强引用（即我们常说的“引用”）相对。

它的特点是，GC在回收时会忽略掉弱引用，即就算有弱引用指向某对象，但只要该对象没有被强引用指向，该对象就会在被GC检查到时回收掉。


对于上面在子线程中下载文件的示例代码，改为采用WeakReference之后，如果任务未执行完但是用户却关闭了MainActivity，但由于仅有一个来自MyHandler的弱引用指向MainActivity，所以GC仍然会在检查时把MainActivity回收掉。这样，内存泄露的问题就不会出现了。


相关推荐