Android学习之 关于内部Handler类引起内存泄露

转载自：http://blog.chengyunfeng.com/?p=468

今天在oschina上有看到这样一个面试题：

    谈谈这段代码的缺陷并改进：

public class MainActivity extends Activity{

Handler mHandler = new MyHandler();

class MyHandler extends Handler{...}

}

说实在的，当看到这个题目的时候，确实有点没搞明白、也不知道怎么去回答这个问题？如是晚上回家在网上寻找了一下答案，看完后 有所领悟吧！(感叹一下、唔基础还是不够扎实啊)觉得还是有必要在这里记载一下：

文字转载于：http://blog.chengyunfeng.com/?p=468

如果您在Activity中定义了一个内部Handler类，如下代码：

[java]  view plain  copy

 

1. public class MainActivity extends Activity {    
2.      
3.       private  Handler mHandler = new Handler() {    
4.           @Override    
5.           public void handleMessage(Message msg) {    
6.               //TODO handle message...    
7.          }    
8.      
9.      };    
10.      
11.     @TargetApi(11)    
12.     @Override    
13.     public void onCreate(Bundle savedInstanceState) {    
14.         super.onCreate(savedInstanceState);    
15.         setContentView(R.layout.activity_main);    
16.         mHandler.sendMessageDelayed(Message.obtain(), 60000);    
17.      
18.         //just finish this activity    
19.         finish();    
20.     }    
21. }    

然后运行Android Lint工具会有一个内存泄露警告:

This Handler class should be static or leaks might occur (com.example.ta.MainActivity.1)

Issue: Ensures that Handler classes do not hold on to a reference to an outer class Id: HandlerLeak

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

Messages enqueued on the application thread’s MessageQueue also retain their target Handler. I

f 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实现了一个简单的消息队列，一个一个的处理里面的Message对象。主线程Looper对象在整个应用生命周期中存在。
2. 当在主线程中初始化Handler时，该Handler和Looper的消息队列关联。发送到消息队列的Message会引用发送该消息的Handler对象，这样系统可以调用 Handler#handleMessage(Message) 来分发处理该消息。
3. 在Java中，非静态(匿名)内部类会引用外部类对象。而静态内部类不会引用外部类对象。
4. 如果外部类是Activity，则会引起Activity泄露 。

当Activity finish后，延时消息会继续存在主线程消息队列中1分钟，然后处理消息。而该消息引用了Activity的Handler对象，然后这个Handler又引用了这个Activity。这些引用对象会保持到该消息被处理完，这样就导致该Activity对象无法被回收，从而导致了上面说的 Activity泄露。

要修改该问题，只需要按照Lint提示的那样，把Handler类定义为静态即可，然后通过WeakReference 来保持外部的Activity对象。

[java]  view plain  copy

 

1. private Handler mHandler = new MyHandler(this);  
2.       private static class MyHandler extends Handler{  
3.       private final WeakReference<Activity> mActivity;  
4.       public MyHandler(Activity activity) {  
5.           mActivity = new WeakReference<Activity>(activity);  
6.       }  
7.      @Override  
8.      public void handleMessage(Message msg) {  
9.         System.out.println(msg);  
10.         if(mActivity.get() == null) {  
11.             return;  
12.         }  
13.     }  
14. }  

所以，当你在Activity中使用内部类的时候，需要时刻考虑您是否可以控制该内部类的生命周期，如果不可以，则最好定义为静态内部类。