Android 中 Handler 引发的内存泄露

在Android经常使用编程中，Handler在进行异步操做并处理返回结果时常常被使用。一般咱们的代码会这样实现。

1.  public class SampleActivity extends Activity { 

2.   

3.    private final Handler mLeakyHandler = new Handler() { 

4.      @Override 

5.      public void handleMessage(Message msg) { 

6.        // ...  

7.      } 

8.    } 

9.  } 

可是，其实上面的代码可能致使内存泄露，当你使用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

看到这里，可能仍是有一些搞不清楚，代码中哪里可能致使内存泄露，又是如何致使内存泄露的呢？由移动应用安全团队-爱内测（www.ineice.com）的技术工程师为咱们分析下：

1.当一个Android应用启动的时候，会自动建立一个供应用主线程使用的Looper实例。Looper的主要工做就是一个一个处理消息队列中 的消息对象。在Android中，全部Android框架的事件（好比Activity的生命周期方法调用和按钮点击等）都是放入到消息中，而后加入到 Looper要处理的消息队列中，由Looper负责一条一条地进行处理。主线程中的Looper生命周期和当前应用同样长。

2.当一个Handler在主线程进行了初始化以后，咱们发送一个target为这个Handler的消息到Looper处理的消息队列时，实际上 已经发送的消息已经包含了一个Handler实例的引用，只有这样Looper在处理到这条消息时才能够调用 Handler#handleMessage(Message)完成消息的正确处理。

3.在Java中，非静态的内部类和匿名内部类都会隐式地持有其外部类的引用。静态的内部类不会持有外部类的引用。确实上面的代码示例有点难以察觉内存泄露，那么下面的例子就很是明显了

1.  public class SampleActivity extends Activity { 

2.   

3.    private final Handler mLeakyHandler = new Handler() { 

4.      @Override 

5.      public void handleMessage(Message msg) { 

6.        // ... 

7.      } 

8.    } 

9.   

10.   @Override 

11.   protected void onCreate(Bundle savedInstanceState) { 

12.     super.onCreate(savedInstanceState); 

13.  

14.     // Post a message and delay its execution for 10 minutes. 

15.     mLeakyHandler.postDelayed(new Runnable() { 

16.       @Override 

17.       public void run() { /* ... */ } 

18.     }, 1000 * 60 * 10); 

19.  

20.     // Go back to the previous Activity. 

21.     finish(); 

22.   } 

23. } 

分析一下上面的代码，当咱们执行了Activity的finish方法，被延迟的消息会在被处理以前存在于主线程消息队列中10分钟，而这个消息中 又包含了Handler的引用，而Handler是一个匿名内部类的实例，其持有外面的SampleActivity的引用，因此这致使了 SampleActivity没法回收，进行致使SampleActivity持有的不少资源都没法回收，这就是咱们常说的内存泄露。

注意上面的new Runnable这里也是匿名内部类实现的，一样也会持有SampleActivity的引用，也会阻止SampleActivity被回收。

要解决这种问题，思路就是不适用非静态内部类，继承Handler时，要么是放在单独的类文件中，要么就是使用静态内部类。由于静态的内部类不会持有外部类的引用，因此不会致使外部类实例的内存泄露。当你须要在静态内部类中调用外部的Activity时，咱们可使用弱引用来处理。另外关于一样也须要将Runnable设置为静态的成员属性。注意：一个静态的匿名内部类实例不会持有外部类的引用。 修改后不会致使内存泄露的代码以下

1.  public class SampleActivity extends Activity { 

2.   

3.    /** 

4.     * Instances of static inner classes do not hold an implicit 

5.     * reference to their outer class. 

6.     */ 

7.    private static class MyHandler extends Handler { 

8.      private final WeakReference<SampleActivity> mActivity; 

9.   

10.     public MyHandler(SampleActivity activity) { 

11.       mActivity = new WeakReference<SampleActivity>(activity); 

12.     } 

13.  

14.     @Override 

15.     public void handleMessage(Message msg) { 

16.       SampleActivity activity = mActivity.get(); 

17.       if (activity != null) { 

18.         // ... 

19.       } 

20.     } 

21.   } 

22.  

23.   private final MyHandler mHandler = new MyHandler(this); 

24.  

25.   /** 

26.    * Instances of anonymous classes do not hold an implicit 

27.    * reference to their outer class when they are "static". 

28.    */ 

29.   private static final Runnable sRunnable = new Runnable() { 

30.       @Override 

31.       public void run() { /* ... */ } 

32.   }; 

33.  

34.   @Override 

35.   protected void onCreate(Bundle savedInstanceState) { 

36.     super.onCreate(savedInstanceState); 

37.  

38.     // Post a message and delay its execution for 10 minutes. 

39.     mHandler.postDelayed(sRunnable, 1000 * 60 * 10); 

40.  

41.     // Go back to the previous Activity. 

42.     finish(); 

43.   } 

44. } 

其实在Android中不少的内存泄露都是因为在Activity中使用了非静态内部类致使的，就像本文提到的同样，因此当咱们使用时要非静态内部 类时要格外注意，若是其实例的持有对象的生命周期大于其外部类对象，那么就有可能致使内存泄露。