ndroid性能优化之利用LeakCanary检测内存泄漏及解决办法

最新推荐文章于 2024-01-15 09:22:13 发布
最新推荐文章于 2024-01-15 09:22:13 发布
阅读量303 收藏
点赞数
分类专栏： Android工作中遇到的问题

转载自：http://www.cnblogs.com/whoislcj/p/6001422.html


前言：

   最近公司C轮融资成功了，移动团队准备扩大一下，需要招聘Android开发工程师，陆陆续续面试了几位Android应聘者，面试过程中聊到性能优化中如何避免内存泄漏问题时，很少有人全面的回答上来。所以决定抽空学习总结一下这方面的知识，以及分享一下我们是如何检测内存泄漏的。我们公司使用开源框架LeakCanary来检测内存泄漏。

什么是内存泄漏？

    有些对象只有有限的生命周期。当它们的任务完成之后，它们将被垃圾回收。如果在对象的生命周期本该结束的时候，这个对象还被一系列的引用，这就会导致内存泄漏。随着泄漏的累积，app将消耗完内存。

内存泄漏造成什么影响？

    它是造成应用程序OOM的主要原因之一。由于android系统为每个应用程序分配的内存有限，当一个应用中产生的内存泄漏比较多时，就难免会导致应用所需要的内存超过这个系统分配的内存限额，这就造成了内存溢出而导致应用Crash。

什么是LeakCanary？

      leakCanary是Square开源框架，是一个Android和Java的内存泄露检测库，如果检测到某个 activity 有内存泄露，LeakCanary 就是自动地显示一个通知，所以可以把它理解为傻瓜式的内存泄露检测工具。通过它可以大幅度减少开发中遇到的oom问题，大大提高APP的质量。

     本篇不介绍如何使用LeakCanary，关于LeakCanary使用参考以下文章：

     1.LeakCanary: 让内存泄露无所遁形 
     2.LeakCanary 中文使用说明

LeakCanary捕获常见内存泄漏以及解决办法

1.）错误使用单例造成的内存泄漏

     在平时开发中单例设计模式是我们经常使用的一种设计模式，而在开发中单例经常需要持有Context对象，如果持有的Context对象生命周期与单例生命周期更短时，或导致Context无法被释放回收，则有可能造成内存泄漏，错误写法如下：

复制代码 
public class LoginManager {
    private static LoginManager mInstance;
    private Context mContext;

    private LoginManager(Context context) {
        this.mContext = context;
    }


    public static LoginManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (LoginManager.class) {
                if (mInstance == null) {
                    mInstance = new LoginManager(context);
                }
            }
        }
        return mInstance;
    }

    public void dealData() {
    }

}
复制代码

弱我们在一个Activity中调用的，然后关闭该Activity则会出现内存泄漏。

LoginManager.getInstance(this).dealData();

LeakCanary检测结果如下：

 解决 办法要保证Context和AppLication的生命周期一样，修改后代码如下：

复制代码 
public class LoginManager {
    private static LoginManager mInstance;
    private Context mContext;

    private LoginManager(Context context) {
        this.mContext = context.getApplicationContext();
    }


    public static LoginManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (LoginManager.class) {
                if (mInstance == null) {
                    mInstance = new LoginManager(context);
                }
            }
        }
        return mInstance;
    }

    public void dealData() {
    }

}
复制代码
2.）Handler造成的内存泄漏

   早些年Handler的使用频率还是蛮高的，它是工作线程与UI线程之间通讯的桥梁，只是现在大量开源框架对其进行了封装，我们这里模拟一种常见使用方式来模拟内存泄漏情形。

复制代码 
public class MainActivity extends AppCompatActivity {
    private Handler mHandler = new Handler();
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.text);//模拟内存泄露
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                mTextView.setText("lcj");
            }
        }, 3 * 60 * 1000);
        finish();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        LApplication.getRefWatcher().watch(this);
    }
}
复制代码

上述代码通过内部类的方式创建mHandler对象,此时mHandler会隐式地持有一个外部类对象引用这里就是MainActivity，当执行postDelayed方法时，该方法会将你的Handler装入一个Message，并把这条Message推到MessageQueue中，MessageQueue是在一个Looper线程中不断轮询处理消息，那么当这个Activity退出时消息队列中还有未处理的消息或者正在处理消息，而消息队列中的Message持有mHandler实例的引用，mHandler又持有Activity的引用，所以导致该Activity的内存资源无法及时回收，引发内存泄漏。

LeakCanary检测结果如下：

  要想避免Handler引起内存泄漏问题，需要我们在Activity关闭退出的时候的移除消息队列中所有消息和所有的Runnable。上述代码只需在onDestroy()函数中调用mHandler.removeCallbacksAndMessages(null);就行了。

复制代码 
public class MainActivity1 extends AppCompatActivity {
    private Handler mHandler = new Handler();
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.text);
        //模拟内存泄露
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                mTextView.setText("lcj");
            }
        }, 3 * 60 * 1000);
        finish();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
        mHandler=null;
        LApplication.getRefWatcher().watch(this);
    }
}
复制代码
 3.)线程造成的内存泄漏

  最早时期的时候处理耗时操作多数都是采用Thread+Handler的方式，后来逐步被AsyncTask取代，直到现在采用RxJava的方式来处理异步。这里以AsyncTask为例，可能大部分人都会这样处理一个耗时操作然后通知UI更新结果：

复制代码 
public class MainActivity extends AppCompatActivity {
    private AsyncTask<Void, Void, Integer> asyncTask;
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.text);
        testAsyncTask();
        finish();
    }

    private void testAsyncTask() {
        asyncTask = new AsyncTask<Void, Void, Integer>() {
            @Override
            protected Integer doInBackground(Void... params) {
                int i = 0;
                //模拟耗时操作
                while (!isCancelled()) {
                    i++;
                    if (i > 1000000000) {
                        break;
                    }
                    Log.e("LeakCanary", "asyncTask---->" + i);
                }
                return i;
            }

            @Override
            protected void onPostExecute(Integer integer) {
                super.onPostExecute(integer);
                mTextView.setText(String.valueOf(integer));
            }
        };
        asyncTask.execute();

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        LApplication.getRefWatcher().watch(this);
    }

}
复制代码

对于上面的例子来说，在处理一个比较耗时的操作时，可能还没处理结束MainActivity就执行了退出操作，但是此时AsyncTask依然持有对MainActivity的引用就会导致MainActivity无法释放回收引发内存泄漏。

LeakCanary检测结果：

如何解决这种内存泄漏呢？在使用AsyncTask时，在Activity销毁时候也应该取消相应的任务AsyncTask.cancel()方法，避免任务在后台执行浪费资源，进而避免内存泄漏的发生。

复制代码 
public class MainActivity3 extends AppCompatActivity {
    private AsyncTask<Void, Void, Integer> asyncTask;
    private TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.text);
        testAsyncTask();
        finish();
    }

    private void testAsyncTask() {
        asyncTask = new AsyncTask<Void, Void, Integer>() {
            @Override
            protected Integer doInBackground(Void... params) {
                int i = 0;
                //模拟耗时操作
                while (!isCancelled()) {
                    i++;
                    if (i > 1000000000) {
                        break;
                    }
                    Log.e("LeakCanary", "asyncTask---->" + i);
                }
                return i;
            }

            @Override
            protected void onPostExecute(Integer integer) {
                super.onPostExecute(integer);
                mTextView.setText(String.valueOf(integer));
            }
        };
        asyncTask.execute();

    }

    private void destroyAsyncTask() {
        if (asyncTask != null && !asyncTask.isCancelled()) {
            asyncTask.cancel(true);
        }
        asyncTask = null;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        destroyAsyncTask();
        LApplication.getRefWatcher().watch(this);
    }

}
复制代码
 4.）非静态内部类创建静态实例造成的内存泄漏

  有时我们需要一个可以随着屏幕旋转的Activity，比如视频播放Activity，这时我们为了防止多次调用onCreate方法导致某些参数重新初始化，我们一般会选择创建一个内部类和一个静态实例来保存这些参数，比如以下实现：

复制代码 
public class MainActivity extends AppCompatActivity {
    private static Config mConfig;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //模拟内存泄露
        if (mConfig == null) {
            mConfig = new Config();
            mConfig.setSize(18);
            mConfig.setTitle("老九门");
        }
        finish();
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        LApplication.getRefWatcher().watch(this);
    }

    class Config {
        private int size;
        private String title;

        public int getSize() {
            return size;
        }

        public void setSize(int size) {
            this.size = size;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }
    }
}
复制代码

  上述代码看着没有任何问题，其实内部类都会持有一个外部类引用，这里这个外部类就是MainActivity，然而内部类实例又是static静态变量其生命周期与Application生命周期一样，所以在MainActivity关闭的时候，内部类静态实例依然持有对MainActivity的引用，导致MainActivity无法被回收释放，引发内存泄漏。LeakCanary检测内存泄漏结果如下：

对于这种泄漏的解决办法就是将内部类改成静态内部类，不再持有对MainActivity的引用即可，修改后的代码如下：

复制代码 
public class MainActivity extends AppCompatActivity {
    private static Config mConfig;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //模拟内存泄露
        if (mConfig == null) {
            mConfig = new Config();
            mConfig.setSize(18);
            mConfig.setTitle("老九门");
        }
        finish();
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        LApplication.getRefWatcher().watch(this);
    }

    static class Config {
        private int size;
        private String title;

        public int getSize() {
            return size;
        }

        public void setSize(int size) {
            this.size = size;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }
    }
}
复制代码
 5.）由WebView引起的内存泄漏

 在目前的开发中多多少少会用到Hybrid开发方式，这样我们就会用WebView去承载Html网页，就如下面这种方式：

java代码：

复制代码 
public class MainActivity5 extends AppCompatActivity {
    private WebView mWebView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_web);
        mWebView = (WebView) findViewById(R.id.web);
        mWebView.loadUrl("http://www.cnblogs.com/whoislcj/p/5720202.html");
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        LApplication.getRefWatcher().watch(this);
    }

}
复制代码

xml布局文件：

复制代码 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <WebView
        android:id="@+id/web"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
</LinearLayout>
复制代码

WebView解析网页时会申请Native堆内存用于保存页面元素，当页面较复杂时会有很大的内存占用。如果页面包含图片，内存占用会更严重。并且打开新页面时，为了能快速回退，之前页面占用的内存也不会释放。有时浏览十几个网页，都会占用几百兆的内存。这样加载网页较多时，会导致系统不堪重负，最终强制关闭应用，也就是出现应用闪退或重启。及时Activity关闭时在onDestroy中调用如下代码也是没有任何作用。

复制代码 
private void destroyWebView() {
        if (mWebView != null) {
            mLinearLayout.removeView(mWebView);
            mWebView.pauseTimers();
            mWebView.removeAllViews();
            mWebView.destroy();
            mWebView = null;
        }
    }
复制代码

先看下LeakCanary检测到的结果如下：

该如何解决呢？这个查了不少资料，其中一种就是使用getApplicationgContext作为参数构建WebView，然后动态添加到一个ViewGroup中，最后退出的时候调用webView的销毁的函数，虽然也达到了防止内存溢出的效果，但是在有些网页弹出时候需要记住密码的对话框的时候，会出现Unable to add window -- token null is not for an application 的错误，所以这里采用的解决办法是通过把使用了WebView的Activity(或者Service)放在单独的进程里。然后在检测到应用占用内存过大有可能被系统干掉或者它所在的Activity(或者Service)结束后，调用android.os.Process.killProcess(android.os.Process.myPid());，主动Kill掉进程。由于系统的内存分配是以进程为准的，进程关闭后，系统会自动回收所有内存。

修改后的代码如下：

复制代码 
public class MainActivity5 extends AppCompatActivity {
    private WebView mWebView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_web);
        mWebView = (WebView) findViewById(R.id.web);
        mWebView.loadUrl("http://www.cnblogs.com/whoislcj/p/5720202.html");
    }

    @Override
    protected void onDestroy() {
        destroyWebView();
        android.os.Process.killProcess(android.os.Process.myPid());
        super.onDestroy();
        LApplication.getRefWatcher().watch(this);

    }

    private void destroyWebView() {
        if (mWebView != null) {
            mWebView.pauseTimers();
            mWebView.removeAllViews();
            mWebView.destroy();
            mWebView = null;
        }
    }

}
复制代码 
manifest中对应的activity配置如下：
<activity
   android:name=".MainActivity5"
   android:process="com.whoislcj.webview"/>
6.）资源未关闭造成的内存泄漏

     对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源的使用，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄漏。例如获取媒体库图片地址代码在查询结束的时候一定要调用

Cursor 的关闭方法防止造成内存泄漏。

复制代码 
     String columns[] = new String[]{
                MediaStore.Images.Media.DATA, MediaStore.Images.Media._ID, MediaStore.Images.Media.TITLE, MediaStore.Images.Media.DISPLAY_NAME
        };
        Cursor cursor = this.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, columns, null, null, null);
        if (cursor != null) {
            int photoIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            //显示每张图片的地址，但是首先要判断一下，Cursor是否有值
            while (cursor.moveToNext()) {
                String photoPath = cursor.getString(photoIndex); //这里获取到的就是图片存储的位置信息
                Log.e("LeakCanary", "photoPath---->" + photoPath);
            }
            cursor.close();
        }
复制代码

总结：

  以上就是通过LeakCanary检测到的内存泄漏情况以及解决办法。


Android 性能优化 利用LeakCanary检测内存泄漏及解决办法
码点
11-14 1050
Android性能优化之利用LeakCanary检测内存泄漏及解决办法 什么是内存泄漏？ &amp;nbsp; &amp;nbsp;&amp;nbsp;有些对象只有有限的生命周期。当它们的任务完成之后，它们将被垃圾回收。如果在对象的生命周期本该结束的时候，这个对象还被一系列的引用，这就会导致内存泄漏。随着泄漏的累积，app将消耗完内存。 内存泄漏造成什么影响？ &amp;nbsp; &amp;nbsp; 它是造成应用程序OO...
内存泄漏：原因与解决办法
ByteProwl的博客
10-04 664
内存泄漏是指在程序中动态分配的内存空间在不再使用时没有被正确释放的情况。这种情况会导致内存持续被占用，最终导致系统性能下降或者崩溃。本文将详细介绍内存泄漏的原因，并提供一些解决办法。内存泄漏是指在编程中动态分配的内存空间在不再使用时未被正确释放的情况。这种情况会导致内存持续被占用，最终导致系统性能下降或崩溃。本文将详细介绍内存泄漏的原因，并提供一些解决办法。
LeakCanary
chewbee的专栏
11-27 1127
LeakCanary原理浅析1.LeakCanary简介LeakCanary是一个Android和Java的内存泄漏检测库，可以大幅可以大幅度减少了开发中遇到的OOM问题。LeakCanary开源库的地址为：LeakCanary开源库LeakCanary的README地址如下：LeakCanary的README2.如何使用LeakCanary使用LeakCanary非常简单，只需要在Applicat
Android性能优化之利用LeakCanary检测内存泄漏及解决办法
11-01 1115
前言： 最近公司C轮融资成功了，移动团队准备扩大一下，需要招聘Android开发工程师，陆陆续续面试了几位Android应聘者，面试过程中聊到性能优化中如何避免内存泄漏问题时，很少有人全面的回答上来。所以决定抽空学习总结一下这方面的知识，以及分享一下我们是如何检测内存泄漏的。我们公司使用开源框架LeakCanary来检测内存泄漏。 什么是内存泄漏？ 有些对象只有有限的...
内存泄露原因和解决方案
xiaoke815的专栏
03-09 6076
资料参考出自： http://blog.chinaunix.net/uid-26930580-id-3844811.html http://www.jianshu.com/p/90caf813682d 为什么会产生内存泄漏？ 当一个对象已经不需要再使用本该被回收时，另外一个正在使用的对象持有它的引用从而导致它不能被回收，这导致本该被回收的对象不能被回收而停留在堆内存中，这就产生
java慢场景_jvm调优的几种场景
weixin_32892145的博客
02-27 563
假定你已经了解了运行时的数据区域和常用的垃圾回收算法，也了解了Hotspot支持的垃圾回收器。一、cpu占用过高cpu占用过高要分情况讨论，是不是业务上在搞活动，突然有大批的流量进来，而且活动结束后cpu占用率就下降了，如果是这种情况其实可以不用太关心，因为请求越多，需要处理的线程数越多，这是正常的现象。话说回来，如果你的服务器配置本身就差，cpu也只有一个核心，这种情况，稍微多一点流量就真的能够...
深入探讨内存泄漏的原因及解决方法
最新发布
qq_52645134的博客
01-15 4096
在深入讨论内存泄漏的原因之前，我们先来了解一下什么是内存泄漏。内存泄漏是指程序在运行时，由于一些错误或设计缺陷，未能正确释放已经分配的内存，导致这部分内存无法再被程序使用，却也无法被操作系统回收。随着程序运行的时间增长，这种未释放的内存会不断累积，最终导致系统的内存耗尽，引发程序崩溃或系统变慢等问题。
Android性能优化之利用强大的LeakCanary检测内存泄漏及解决办法
01-20
在进行性能优化时，除了防止内存泄漏，还需要关注其他方面，比如减少不必要的资源加载、优化图片加载、使用高效的数据结构和算法、合理调度任务、避免过度绘制等。通过结合LeakCanary等工具，我们可以有效地检测并...
Android性能优化：用LeakCanary深度检测与修复内存泄漏
本文主要介绍了Android应用开发中的内存泄漏问题，以及如何利用LeakCanary这一开源库进行检测和解决。 内存泄漏是Android应用性能优化中的一个重要环节。当一个对象在其生命周期结束后，若仍有其他对象持有对它的...
内存泄漏的原因及解决方法
yezi153的博客
11-15 5925
内存泄漏就是内存中的变量没有回收，一直存在与内存中，造成内存的浪费的行为。常见的内存泄漏有以下5种 1. 意外的全局变量 2. 计时器和回调函数timers 3. DOM泄漏 4. js闭包 5. console <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta http-equiv="X-UA-Compatible" conte
如何解决内存泄漏
weixin_35754676的博客
12-22 667
内存泄漏是指程序中已分配的内存在不再使用时无法被正常释放，导致系统内存资源的浪费。内存泄漏会导致程序运行效率降低，甚至可能导致系统崩溃。 要解决内存泄漏，需要从以下几个方面入手： 使用内存管理工具：通常编程语言都会提供内存管理工具，如 Java 中的垃圾回收机制，C++ 中的 delete 和 free 等，能够自动回收不再使用的内存。 检查代码：检查程序中是否存在分配了内存但无法释放的情况，...
检测内存泄漏常用工具之Leakcanary
superMrLiu的博客
09-30 649
在遇到Leakcanary之前，排查Android开发时发生内存泄漏问题，真是蛋疼的要命，后来技术发烧友向我推荐了Leakcanary这款利器，我试着集成到开发项目中，不得了了：内存泄漏定位准确（比如持有static的强引用对象窗体结束后仍然未销毁），让我在解决时候有了一个明确的方向感。让我优雅的处理内存泄漏的排查和解决。感谢Square神器Leakcanary，github开源地址：https:/
LeakCanary使用
cxjwpp的博客
10-24 82
转载自：https://www.jianshu.com/p/bcaab8f0f280
LeakCanary 使用
时代我西的博客
03-07 2648
LeakCanary github地址:LeakCanary 要使用 LeakCanary，请将leakcanary-android依赖项添加到应用程序的build.gradle文件中： dependencies { // debugImplementation because LeakCanary should only run in debug builds. debugImplementation 'com.squareup.leakcanary:leakcanary-android:
LeakCanary的使用
cxjwpp的博客
07-13 115
转载自：https://www.jianshu.com/p/c32f9aa85f18
leakcanary的使用
小雨的博客
10-09 2202
它是什么 一句话说，就是： Android项目中，用于检测内存泄露，优化性能的工具 解决了什么问题 解决了，内存泄漏难以发现的问题。通过Leakcanary，可以轻松的找到GC中跟搜索法可达，然而不再使用的对象。 一般情况下，这种问题是很难被发现的，原因是他的出现是不经意间的，其中，内存泄露常见的场景有： 内存泄露常见场景 非静态内部类的静态实例 非静态内部类会持有外部类的引用 在外部类生命周期结束后，静态实例会长期维持着外部类的引用，导致无法被gc 多线程相关的匿名内部类\非静态内部类
Leakcanary的使用
hujin2017的博客
11-06 877
LeakCanary是Android查找内存泄漏的主要工具，由Square公司开发，可以直接在手机端查看内存泄露的工具。其使用方法如下： 第一步： debugCompile 'com.squareup.leakcanary:leakcanary-android:1.6.1' releaseCompile 'com.squareup.leakcanary:leakcanary-and...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值