Handler导致的内存泄露分析以及内存泄露检测工具LeakCanary的集成

单刀直入，来吧！

引入：

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (msg.what == MSG_WHAT) {
                String str = (String) msg.obj;
                Log.i(TAG, "handleMessage:str::" + str);
            }
        }
    };
//*********************
private void sendMsg(){
   mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        Message msg = new Message();
                        msg.what = MSG_WHAT;
                        msg.obj = "你好世界！";
                        mHandler.sendMessage(msg);
                                           }
                }, 3000);
          }
//******************
  @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mHandler != null) {
            mHandler.removeCallbacksAndMessages(null);
            mHandler=null;
        }

    }
    
    
     
     1
     
     2
     
     3
     
     4
     
     5
     
     6
     
     7
     
     8
     
     9
     
     10
     
     11
     
     12
     
     13
     
     14
     
     15
     
     16
     
     17
     
     18
     
     19
     
     20
     
     21
     
     22
     
     23
     
     24
     
     25
     
     26
     
     27
     
     28
     
     29
     
     30
     
     31
     
     32

上面的代码熟悉么？大家应该经常使用。殊不知，上述代码已经造成了内存泄露。As会发出如下警告：

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

排除误区：.

有些同学认为在onDestory中执行

Handler.removeCallbacksAndMessages(null);
    
    
     
     1

就能避免内存泄露。是这样，上述方式存在的必要性只是进一步减少了内存泄露的风险——在Activity被销毁的时候，将消息队列清空。但是不能完全避免内存谢泄露。下面的泄露原因会说。

关于内存泄露的检测，建议大家使用LeakCanary内存检测工具。后面再说。

二、分析

1、 Android角度

当Android应用程序启动时，framework会为该应用程序的主线程创建一个Looper对象。这个Looper对象包含一个简单的消息队列Message Queue，并且能够循环的处理队列中的消息。这些消息包括大多数应用程序framework事件，例如Activity生命周期方法调用、button点击等，这些消息都会被添加到消息队列中并被逐个处理。另外，主线程的Looper对象会伴随该应用程序的整个生命周期。

然后，当主线程里，实例化一个Handler对象后，它就会自动与主线程Looper的消息队列关联起来。所有发送到消息队列的消息Message都会拥有一个对Handler的引用，所以当Looper来处理消息时，会据此回调[Handler#handleMessage(Message)](http://developer.android.com/reference/android/os/Handler.html#handleMessage(android.os.Message)方法来处理消息。

2、 Java角度
在java里，非静态内部类和匿名类都会潜在的引用它们所属的外部类。但是，静态内部类却不会.

三、分泄露原因

当activity结束(finish)时，里面的延时消息在得到处理前，会一直保存在主线程的消息队列里持续3秒钟。而且，由上文可知，这条消息持有对handler的引用，而handler又持有对其外部类（在这里，即MainActivity）的潜在引用。这条引用关系会一直保持直到消息得到处理，从而，这阻止了MainActivity被垃圾回收器回收，同时造成应用程序的泄漏。
注意，上面代码中的Runnable类–非静态匿名类–同样持有对其外部类的引用。从而也导致泄漏。

四、泄漏解决方案

首先，上面已经明确了内存泄漏来源：
1.只要有未处理的消息，那么消息会引用handler，非静态的handler又会引用外部类，即Activity，导致Activity无法被回收，造成泄漏；

2.Runnable类属于非静态匿名类，同样会引用外部类。

为了解决遇到的问题，我们要明确一点：静态内部类不会持有对外部类的引用。所以，我们可以把handler类放在单独的类文件中，或者使用静态内部类便可以避免泄漏。

另外，如果想要在handler内部去调用所在的外部类Activity，那么可以在handler内部使用弱引用的方式指向所在Activity，这样统一不会导致内存泄漏。对于匿名类Runnable，同样可以将其设置为静态类。因为静态的匿名类不会持有对外部类的引用

 private static class MyHandler extends Handler {
    //弱引用
        private final WeakReference<MainActivity> mActivity;

        public MyHandler(MainActivity activity) {
            mActivity = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            Log.i(TAG, "handleMessage: msg::" + msg);
            if (msg.what == MSG_WHAT1) {
                String str = (String) msg.obj;
                Log.i(TAG, "handleMessage:str::" + str);
                MainActivity activity = mActivity.get();
                //静态内部类中，Context不能直接传入MainActivity.this
                Toast.makeText(activity, str, Toast.LENGTH_SHORT).show();

            }

        }
    }


    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            Log.i(TAG, "run: MyRunnable");
            Message msg1 = new Message();
            msg1.what = MSG_WHAT1;
            msg1.obj = "再见世界！";
            myHandler.sendMessage(msg1);
        }
    }
//************************
private void sendMsg(){
     myHandler = new MyHandler(this);
     myHandler.postDelayed(new MyRunnable(), 3000);
     }
//***********************
 @Override
    protected void onDestroy() {
        super.onDestroy();
            if (myHandler != null) {
            myHandler.removeCallbacksAndMessages(null);
        }
    }
    
    
     
     1
     
     2
     
     3
     
     4
     
     5
     
     6
     
     7
     
     8
     
     9
     
     10
     
     11
     
     12
     
     13
     
     14
     
     15
     
     16
     
     17
     
     18
     
     19
     
     20
     
     21
     
     22
     
     23
     
     24
     
     25
     
     26
     
     27
     
     28
     
     29
     
     30
     
     31
     
     32
     
     33
     
     34
     
     35
     
     36
     
     37
     
     38
     
     39
     
     40
     
     41
     
     42
     
     43
     
     44
     
     45
     
     46
     
     47
     
     48
     
     49

五、小结

虽然静态类与非静态类之间的区别并不大，但是对于Android开发者而言却是必须理解的。至少我们要清楚，如果一个内部类实例的生命周期比Activity更长，那么我们千万不要使用非静态的内部类。最好的做法是，使用静态内部类，然后在该类里使用弱引用来指向所在的Activity。

六、补充

关于使用

Handler.removeCallbacksAndMessages(null);
    
    
     
     1

来清除当前mHandler消息队列。
大家可能还可能见过

Handler.removeMessages(msg.what);
    
    
     
     1

我本来只是简单的认为removeCallbacksAndMessages()是用来移除所有的消息队列，而removeMessages(msg.what)用来移除指定的消息队列。可是当我打log的时候发现，使用removeMessages(msg.what)并没有移除指定的消息队列。

经过研究发现，上述理解成立前提必须使用：

Handler.sendEmptyMessageDelayed(msg.what, duration);
    
    
     
     1

对于使用了

Handler.sendMessage(Message msg);
    
    
     
     1

的情况下，Handler.removeMessages(msg.what);是不起作用的。大家注意下。反正不管哪种情况，调用Handler.removeCallbacksAndMessages(null);总没错。

七、集成LeakCanary内存检测工具

LeakCanary是Android查找内存泄漏的主要工具，由Square公司开发，可以直接在手机端查看内存泄露的工具。其使用方法如下：

1、导入依赖包

  debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.5'
    releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'
    testImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'
    
    
     
     1
     
     2
     
     3

2、在app的主工程里面创建MyApplication，该类集成Application，在其onCreate方法里面添加如下代码，开启LeakCanary监控。

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        if (LeakCanary.isInAnalyzerProcess(this)) {
            return;
        }
        LeakCanary.install(this);
    }
}

    
    
     
     1
     
     2
     
     3
     
     4
     
     5
     
     6
     
     7
     
     8
     
     9
     
     10
     
     11
     
     12

3、修改配置文件AndroidManifest.xml

android:name=".MyApplication"
    
    
     
     1

并配置权限：

  <!--SDCard中创建与删除文件权限-->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
    <!--向SDCard写入数据权限-->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    
    
     
     1
     
     2
     
     3
     
     4

这样就配置完毕了，这时候把应用安装到手机上之后，就会看到应用的旁边多了一个应用图标。如下图：
这里写图片描述

如此以来，如果你的代码中出现了内存泄露的问题。则会弹出相应的提示，点击进入即可以定位内存泄露的地方。

上面的配置只是对你的activity的内容中存在的泄露进行了监控

1.首先对MyApplication略做些改动，如下：

public class MyApplication extends Application {

    private static RefWatcher mRefWatcher;

    @Override
    public void onCreate() {
        super.onCreate();
        if (LeakCanary.isInAnalyzerProcess(this)) {
            return;
        }
        mRefWatcher = LeakCanary.install(this);
    }

    public static RefWatcher getRefWatcher() {

            return mRefWatcher;

    }
}
    
    
     
     1
     
     2
     
     3
     
     4
     
     5
     
     6
     
     7
     
     8
     
     9
     
     10
     
     11
     
     12
     
     13
     
     14
     
     15
     
     16
     
     17
     
     18
     
     19

2.在Fragment中进行调用：

public class MyFragment extends Fragment {

   @Override
   public void onDestroy() {
       super.onDestroy();
       MyApplication.getRefWatcher().watch(this);
    }
}
    
    
     
     1
     
     2
     
     3
     
     4
     
     5
     
     6
     
     7
     
     8

说明：

1.针对某个模块的内存泄露问题，LeakCanary一次可能值上报一个，因此建议大家解决好一个泄露问题之后，再去解决下一个。

2.针对Android6.0使用LeakCanary不弹出泄露通知的情况，可能是由于Android6.0运行时权限的申请造成的。

针对Android6.0运行时权限的动态申请，有多种方式。推荐两种：
PermissionsDispatcher，Android 6.0 运行时权限
 最简单的实现图片的放大和缩小（就像操作ImageView一样）——–里面第一部分是关于6.0动态权限申请的。

好了，至此完结！有问题请留言。