android 如何查找内存泄漏

转载 2018年04月17日 16:28:47

转载自https://blog.csdn.net/itachi85/article/details/77826112?utm_source=gold_browser_extension
https://blog.csdn.net/u012760183/article/details/52068490

对于内存泄漏,在Android中如果不注意的话,还是很容易出现的,尤其是在Activity中,比较容易出现,下面我就说下自己是如何查找内存泄露的。

首先什么是内存泄漏?

内存泄漏就是一些已经不使用的对象还存在于内存之中且垃圾回收机制无法回收它们,导致它们常驻内存,会使内存消耗越来越大,最终导致程序性能变差。
其中在Android虚拟机中采用的是根节点搜索算法枚举根节点判断是否是垃圾,虚拟机会从GC Roots开始遍历,如果一个节点找不到一条到达GC Roots的路线,也就是没和GC Roots 相连,那么就证明该引用无效,可以被回收,内存泄漏就是存在一些不好的调用导致一些无用对象和GC Roots相连,无法被回收。

既然知道了什么是内存泄漏,自然就知道如何去避免了,就是我们在写代码的时候尽量注意产生对无用对象长时间的引用,说起来简单,但是需要足够的经验才能达到,所以内存泄漏还是比较容易出现的,既然不容易完全避免,那么我们就要能发现程序中出现的内存泄漏并修复它,
下面我就说说如何发现内存泄漏的吧。

查找内存泄漏:

比如说下面这个代码:

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        String string = new String();

    }

    public void click(View view){
        Intent intent = new Intent();
        intent.setClass(getApplicationContext(),SecondActivity.class);
        startActivity(intent);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(8000000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        new Thread(runnable).start();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

每次跳转到这个Activity中时都会调用一个线程,然后这个线程会执行runnable的run方法 由于Runnable是一个匿名内部对象 所以握有SecondActivity的引用,因此
很简单的两个Activity,可由MainActivity跳转到SecondActivity中,
下面我们从MainActivity跳到SecondActivity 然后从SecondActivity返回MainActivity,连续这样5次 ,最终返回MainActivity,按照常理来说,我们从SecondActivity返回MainActivity之后 SecondActivity就该被销毁回收,可实际可能并不是这样。

这时候要判断发没发生内存溢出就要使用工具了!下面有两种方式

1.利用MAT工具查找

首先打开AS中的Android Device Monitor工具 具体位置如下图:
AS Android Device Monitor位置
打开后会出现如下的界面
ADM界面
先选中你要检测的应用的包名,然后点击下图画圈的地方,会在程序包名后标记一个图标

接下来要做的就是操作我们的app 来回跳转5次。
之后点击下图的图标 就可导出hprof文件进行分析了

导出文件如下图所示:
hprof文件
得到了hprof文件 我们就可以利用MAT工具进行分析了,
打开MAT工具
如果没有 可以在下面网址下载
MAT工具下载地址

界面如下图所示:

打开我们先前导出的hprof文件 ,不出意外会报下面的错误

这是因为MAT是用来分析java程序的hprof文件的 与Android导出的hprof有一定的格式区别,因此我们需要把导出的hprof文件转换一下,sdk中提供给我们转换的工具 hprof-conv.exe 在下图的位置
hprof-conv位置
接下来我们cd到这个路径下执行这个命令转换我们的hprof文件即可,如下图
转换hprof文件
其中 hprof-conv 命令 这样使用
hprof-conv 源文件 输出文件
比如 hprof-conv E:\aaa.hprof E:\output.hprof
就是 把aaa.hprof 转换为output.hprof输出 output.hprof就是我们转换之后的文件,图中 mat2.hprof就是我们转换完的文件。

接下来 我们用MAT工具打开转换之后的mat2.hprof文件即可 ,打开后不报错 如下图所示:
MAT打开hprof文件
之后我们就可以查看当前内存中存在的对象了,由于我们内存泄漏一般发生在Activity中,因此只需要查找Activity即可。
点击下图中标记的QQL图标 输入 select * from instanceof android.app.Activity
类似于 SQL语句 查找 Activity相关的信息 点击 红色叹号执行后 如下图所示:
QQL

接下来 我们就可以看到下面过滤到的Activity信息了
如上图所示, 其中内存中还存在 6个SecondActivity实例,但是我们是想要全部退出的,这表明出现了内存泄漏

其中 有 Shallow size 和 Retained Size两个属性

Shallow Size
对象自身占用的内存大小,不包括它引用的对象。针对非数组类型的对象,它的大小就是对象与它所有的成员变量大小的总和。
当然这里面还会包括一些java语言特性的数据存储单元。针对数组类型的对象,它的大小是数组元素对象的大小总和。
Retained Size
Retained Size=当前对象大小+当前对象可直接或间接引用到的对象的大小总和。(间接引用的含义:A->B->C, C就是间接引用)
不过,释放的时候还要排除被GC Roots直接或间接引用的对象。他们暂时不会被被当做Garbage。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

接下来 右击一个SecondActivity

选择 with all references
打开如下图所示的页面

查看下图的页面
看到 this0引用了这个Activity而this” role=”presentation” style=”position: relative;”>0Activitythis0引用了这个Activity而this0是表示 内部类的意思,也就是一个内部类引用了Activity 而 this$0又被 target引用 target是一个线程,原因找到了,内存泄漏的原因 就是 Activity被 内部类引用 而内部类又被线程使用 因此无法释放,我们转到这个类的代码处查看

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(8000000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        new Thread(runnable).start();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

确实 在 SecondActivity中 存在Runnable 内部类对象,然后又被线程 使用,而线程要执行8000秒 因此 SecondActivity对象被引用 无法释放,导致了内存溢出。
要解决这种的内存溢出,要及时在Activity退出时结束线程(不过不大好结束。。),或者良好的控制线程执行的时间即可。

这样我们就找出了这个程序中的内存溢出。

2.直接利用Android Studio的 Monitor Memory 查找内存溢出
还是利用上面那个程序,我就简单点说了。

首先 在手机上运行程序,打开AS的 Minotor 界面 查看Memory 图像

点击 小卡车图标(图中1位置图标) 可以触发一次 GC

点击 图中2位置图标可以查看hprof文件

左边是 内存中的对象,在里面找 Activity 看存不存在我们希望已经回收的Activity 如果 出现我们期望已经回收的Activity,单击 就会在右边显示它的总的个数,点击右边的某个,可以显示 它的GC Roots的树关系图 ,查看关系图就可以找出发生内存泄漏的位置(类似于第一种方式)

这样就完成了内存泄漏的查找。

其中内存泄漏产生的原因在Android中大致分为以下几种:

1.static变量引起的内存泄漏
因为static变量的生命周期是在类加载时开始 类卸载时结束,也就是说static变量是在程序进程死亡时才释放,如果在static变量中 引用了Activity 那么 这个Activity由于被引用,便会随static变量的生命周期一样,一直无法被释放,造成内存泄漏。

解决办法:
在Activity被静态变量引用时,使用 getApplicationContext 因为Application生命周期从程序开始到结束,和static变量的一样。

2.线程造成的内存泄漏
类似于上述例子中的情况,线程执行时间很长,及时Activity跳出还会执行,因为线程或者Runnable是Acticvity内部类,因此握有Activity的实例(因为创建内部类必须依靠外部类),因此造成Activity无法释放。
AsyncTask 有线程池,问题更严重

解决办法:
1.合理安排线程执行的时间,控制线程在Activity结束前结束。
2.将内部类改为静态内部类,并使用弱引用WeakReference来保存Activity实例 因为弱引用 只要GC发现了 就会回收它 ,因此可尽快回收

3.BitMap占用过多内存
bitmap的解析需要占用内存,但是内存只提供8M的空间给BitMap,如果图片过多,并且没有及时 recycle bitmap 那么就会造成内存溢出。

解决办法:
及时recycle 压缩图片之后加载图片

4.资源未被及时关闭造成的内存泄漏
比如一些Cursor 没有及时close 会保存有Activity的引用,导致内存泄漏

解决办法:
在onDestory方法中及时 close即可

5.Handler的使用造成的内存泄漏
由于在Handler的使用中,handler会发送message对象到 MessageQueue中 然后 Looper会轮询MessageQueue 然后取出Message执行,但是如果一个Message长时间没被取出执行,那么由于 Message中有 Handler的引用,而 Handler 一般来说也是内部类对象,Message引用 Handler ,Handler引用 Activity 这样 使得 Activity无法回收。

解决办法:
依旧使用 静态内部类+弱引用的方式 可解决

其中还有一些关于 集合对象没移除,注册的对象没反注册,代码压力的问题也可能产生内存泄漏,但是使用上述的几种解决办法一般都是可以解决的。

使用LeakCanary进行内存泄漏分析

如果使用MAT来分析内存问题,会有一些难度,并且效率也不是很高,对于一个内存泄漏问题,可能要进行多次排查和对比。
为了能够简单迅速的发现内存泄漏,Square公司基于MAT开源了LeakCanary

2.使用LeakCanary

首先配置build.gradle:

 dependencies {
   debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5.2'
   releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.2'
 }
  • 1
  • 2
  • 3
  • 4

接下来在Application加入如下代码。

public class LeakApplication extends Application {
    @Override public void onCreate() {
    super.onCreate();
    if (LeakCanary.isInAnalyzerProcess(this)) {//1
      // This process is dedicated to LeakCanary for heap analysis.
      // You should not init your app in this process.
      return;
    }
    LeakCanary.install(this);
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

注释1处的代码用来进行过滤操作,如果当前的进程是用来给LeakCanary 进行堆分析的则return,否则会执行LeakCanary的install方法。这样我们就可以使用LeakCanary了,如果检测到某个Activity 有内存泄露,LeakCanary 就会给出提示。

3.LeakCanary应用举例

第二节的例子代码只能够检测Activity的内存泄漏,当然还存在其他类的内存泄漏,这时我们就需要使用RefWatcher来进行监控。改写Application,如下所示。

public class LeakApplication extends Application {
    private RefWatcher refWatcher;
    @Override
    public void onCreate() {
        super.onCreate();
        refWatcher= setupLeakCanary();
    }
    private RefWatcher setupLeakCanary() {
        if (LeakCanary.isInAnalyzerProcess(this)) {
            return RefWatcher.DISABLED;
        }
        return LeakCanary.install(this);
    }

    public static RefWatcher getRefWatcher(Context context) {
        LeakApplication leakApplication = (LeakApplication) context.getApplicationContext();
        return leakApplication.refWatcher;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

install方法会返回RefWatcher用来监控对象,LeakApplication中还要提供getRefWatcher静态方法来返回全局RefWatcher。
最后为了举例,我们在一段存在内存泄漏的代码中引入LeakCanary监控,如下所示。

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        LeakThread leakThread = new LeakThread();
        leakThread.start();
    }
    class LeakThread extends Thread {
        @Override
        public void run() {
            try {
                Thread.sleep(6 * 60 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        RefWatcher refWatcher = LeakApplication.getRefWatcher(this);//1
        refWatcher.watch(this);
    }
}
  • 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

MainActivity存在内存泄漏,原因就是非静态内部类LeakThread持有外部类MainActivity的引用,LeakThread中做了耗时操作,导致MainActivity无法被释放。关于内存泄漏可以查看Android内存优化(三)避免可控的内存泄漏这篇文章。
在注释1处得到RefWatcher,并调用它的watch方法,watch方法的参数就是要监控的对象。当然,在这个例子中onDestroy方法是多余的,因为LeakCanary在调用install方法时会启动一个ActivityRefWatcher类,它用于自动监控Activity执行onDestroy方法之后是否发生内存泄露。这里只是为了方便举例,如果想要监控Fragment,在Fragment中添加如上的onDestroy方法是有用的。
运行程序,这时会在界面生成一个名为Leaks的应用图标。接下来不断的切换横竖屏,这时会闪出一个提示框,提示内容为:“Dumping memory app will freeze.Brrrr.”。再稍等片刻,内存泄漏信息就会通过Notification展示出来,比如三星S8的通知栏如下所示。

Notification中提示了MainActivity发生了内存泄漏, 泄漏的内存为787B。点击Notification就可以进入内存泄漏详细页,除此之外也可以通过Leaks应用的列表界面进入,列表界面如下图所示。

内存泄漏详细页如下图所示。

点击加号就可以查看具体类所在的包名称。整个详情就是一个引用链:MainActiviy的内部类LeakThread引用了LeakThread的this$0</code>,<code>this$0的含义就是内部类自动保留的一个指向所在外部类的引用,而这个外部类就是详情最后一行所给出的MainActiviy的实例,这将会导致MainActivity无法被GC,从而产生内存泄漏。

除此之外,我们还可以将 heap dump(hprof文件)和info信息分享出去,如下图所示。
device-2017-09-02-181759_副本.png

需要注意的是分享出去的hprof文件并不是标准的hprof文件,还需要将它转换为标准的hprof文件,这样才会被MAT识别从而进行分析,关于MAT可以查看Android内存优化(五)详解内存分析工具MAT这篇文章。

解决方法就是将LeakThread改为静态内部类。

public class MainActivity extends AppCompatActivity {
  ...
    static class LeakThread extends Thread {
        @Override
        public void run() {
            try {
                Thread.sleep(6 * 60 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
...
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

再次运行程序LeakThread就不会给出内存泄漏的提示了。

参考资料
《高性能Android应用开发》
使用LeakCanary检测安卓中的内存泄漏(实战)
https://github.com/square/leakcanary
LeakCanary 中文使用说明
Android 源码系列之<十三>从源码的角度深入理解LeakCanary的内存泄露检测机制(中)

使用Android studio分析内存泄露

Android内存泄漏分析及调试

java对象的强引用,软引用,弱引用和虚引用

Android内存泄漏终极解决篇(下)

Android内存泄漏查找和解决

内存泄漏的概念 一个内存泄漏的例子 Java中”失效”的private修饰符 回头看内存泄漏例子泄漏的重点 强引用与弱引用 解决内部类的内存泄漏 Context造成的泄漏 ...
  • xyq046463
  • xyq046463
  • 2016-06-27 17:13:49
  • 10805

查找内存泄漏的一个思路

做了持久压力测试,发现内存增长的很快,注释大法查了半天发现两个泄漏点,不过代码太多了,分开调试又很麻烦,所以就想看看内存里面到底是啥。 总结了下方法: 1)启动程序 2)获取程序的 3)cp /pro...
  • yatusiter
  • yatusiter
  • 2016-04-11 16:27:34
  • 914

内存泄漏查找c++ new delete

#include #include struct MemIns { void *pMem; int m_nSize; char m_szFileName[256]; ...
  • occupy8
  • occupy8
  • 2016-04-05 18:52:54
  • 686

Android内存知识及用MAT工具定位内存泄漏的方法

Java内存 Java管理的内存分两种, 堆和栈. 栈是保存函数形参和局部变量的地方, 栈里保存的是对象的引用. 一个正在执行的函数总是存放在栈的最 上层.每个线程都有自己的调用栈. 堆上存放着...
  • zhiwenwei
  • zhiwenwei
  • 2017-03-31 09:31:53
  • 654

java内存泄漏查找

java由于拥有自动垃圾回收机制,所以一般情况下,我们不需要考虑内存泄漏的问题。jvm会自动收回无用的对象。所谓无用的对象,表示你的程序不可能再访问的对象。 但是,有一种情况必须考虑,就是要防止容器...
  • x_studying
  • x_studying
  • 2015-08-29 16:11:43
  • 2012

有关内存泄漏的查找解决思路方法

有关内存泄漏的查找解决思路方法 从网上看到的感觉不错 给大家分享 内存泄漏指的是软件在运行过程中对于申请的内存空间没有释放,导致内存占用越来越大,最后程序异常崩溃,而且此时也不会留下任何痕迹,没...
  • yanjinrong
  • yanjinrong
  • 2014-11-12 11:18:39
  • 1327

如何快速定位Android内存泄漏位置

一.内存泄漏概述            在介绍内存泄漏之前很有必要提及一下Android系统的垃圾回收机制。Java中的垃圾回收机制,是Java与C++/C的主要区别之一,作为Java开发者,一般不需...
  • Stevin_wang
  • Stevin_wang
  • 2016-12-05 21:52:22
  • 1345

查找及定位内存泄露的简单方法

在VC编译器下的做法:在每个头文件中加入:#ifdef _DEBUG  #define new DEBUG_NEW  #undef THIS_FILE  static char THIS_FILE[]...
  • shengy
  • shengy
  • 2008-05-28 17:04:00
  • 323

利用Android中DDMS->Heap工具检测内存泄漏问题

1. 启动eclipse后,切换到DDMS透视图,并确认Devices视图、Heap视图都是打开的; 2. 将手机通过USB链接至电脑,链接时需要确认手机是处于“USB调试”模式,而不是作为...
  • f917386389
  • f917386389
  • 2014-07-24 23:02:19
  • 1374

Android C++层内存泄漏检测

最新在Android项目中遇到C++层内存泄露问题,在此记录解决方法。 1.修改C:\Users\\.android\ddms.cfg,在文件的最后添加"native=true"。 2.连上真机并...
  • hccloud
  • hccloud
  • 2015-02-06 20:13:38
  • 2155
收藏助手
不良信息举报
您举报文章:android 如何查找内存泄漏
举报原因:
原因补充:

(最多只允许输入30个字)