Android 内存泄漏总结

作者: johnnycmj | 来源:发表于2018-01-12 15:31 被阅读56次

Android 性能相关知识

android 是基于java语言的，所以对于内存回收也是用到java 的 GC垃圾回收机制。

垃圾回收原理

垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收

在Android中主要用到标注并清理回收法，程序在运行的过程中不停的创建新的对象并消耗内存，直到内存用光，这时再要创建新对象时，系统暂停其它组件的运行，触发GC线程启动垃圾回收过程。内存回收的原理很简单，就是从所谓的"GC Roots"集合开始，将内存整个遍历一次，保留所有可以被GC Roots直接或间接引用到的对象，而剩下的对象都当作垃圾对待并回收。

内存泄漏根本原因

内存泄露的根本原因就是保存了不可能再被访问的变量类型的引用。
即在进程中某些对象（垃圾对象）已经没有使用价值了，但是它们却可以直接或间接地引用到gc roots导致无法被GC回收。无用的对象占据着内存空间，使得实际可使用内存变小，形象地说法就是内存泄漏了。

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

一、错误使用单例造成的内存泄漏

单例模式或者静态方法长期持有Context对象，如果持有的Context对象生命周期与单例生命周期更短时，或导致Context无法被释放回收，则有可能造成内存泄漏。

例如：

public class LoginManager {

    private static LoginManager mInstance;
    private Context mContext;

    private LoginManager(Context 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检测结果如下：

singleton.png

LeakCanary可以检测到所有泄漏的调用链。

解决办法要保证Context和AppLication的生命周期一样

public class LoginManagerRepair {

    private static LoginManagerRepair mInstance;
    private Context mContext;

    private LoginManagerRepair(Context context) {
        //用 aplicationContext
        this.mContext = context.getApplicationContext();
    }


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

    public void dealData() {

    }
}

二、Handler造成的内存泄漏

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

public class HandlerActivity 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("ceshi");
            }
        },60*1000);
        finish();
    }

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

LeakCanary检测结果如下：

handler.png

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

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

三、AsyncTask 异步

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

例如：

public class AsynTaskActivity 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);
        testAsynTask();

        finish();
    }

    private void testAsynTask(){
        asyncTask = new AsyncTask<Void, Void, Integer>() {
            @Override
            protected Integer doInBackground(Void... voids) {
                int i=0;
                while (!isCancelled()){
                    i++;
                    if(i>10000000000l){
                        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();
        ExampleApplication.getRefWatcher(this).watch(this);
    }
}

LeakCanary检测结果：

asyntask.png

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

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

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

AsyncTask 还有一种内部类的写法：

public class AsynTask2Activity extends AppCompatActivity {

    private TextView mTextView;

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

        mTextView = (TextView) findViewById(R.id.text);

        ScheduleTask scheduleTask = new ScheduleTask();
        scheduleTask.execute();

        finish();
    }

    class ScheduleTask extends AsyncTask<Void, Void, Integer> {

        @Override
        protected Integer doInBackground(Void... voids) {
            int i=0;
            while (!isCancelled()){
                i++;
                if(i>10000000000l){
                    break;
                }
                Log.e("LeakCanary", "asyncTask---->" + i);
            }

            return i;
        }

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


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

一样会导致内存泄漏，可以使用弱引用：

class ScheduleTask extends AsyncTask<Void, Void, Integer> {

        private final WeakReference<Activity> mTarget;

        public ScheduleTask(Activity activity){
            mTarget = new WeakReference<Activity>(activity);
        }

        @Override
        protected Integer doInBackground(Void... voids) {
            int i=0;
            while (!isCancelled()){
                i++;
                if(i>10000000000l){
                    break;
                }
                Log.e("LeakCanary", "asyncTask---->" + i);
            }

            return i;
        }

        @Override
        protected void onPostExecute(Integer integer) {
            super.onPostExecute(integer);
            Activity activity = mTarget.get();
            if (activity == null
                    || activity.isFinishing()) {
                // activity没了,就结束可以了
                return;
            }

            mTextView.setText(String.valueOf(integer));
        }
    }

四、非静态内部类创建静态实例造成的内存泄漏

public class InnerClassActivity extends AppCompatActivity {

    private static Config config;

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

        if(config == null) {
            config = new Config();
            config.setSize(11);
        }

        finish();
    }

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

    class Config {
        private int size;

        public int getSize() {
            return size;
        }

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

    }

}

内部类都会持有一个外部类引用，这里这个外部类就是InnerClassActivity，然而内部类实例又是static静态变量其生命周期与Application生命周期一样，所以在InnerClassActivity关闭的时候，内部类静态实例依然持有对InnerClassActivity的引用，导致InnerClassActivity无法被回收释放，引发内存泄漏。

inner.png

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

static class Config {
        private int size;

        public int getSize() {
            return size;
        }

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

    }

五、由WebView引起的内存泄漏

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.baidu.com");
    }


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

}

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

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

网上一种解决方法是使用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"/>

六、资源未关闭造成的内存泄漏

对于使用了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();
        }

Android 内存泄漏总结

Android 性能相关知识

垃圾回收原理

内存泄漏根本原因

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

一、错误使用单例造成的内存泄漏

二、Handler造成的内存泄漏

三、AsyncTask 异步

四、非静态内部类创建静态实例造成的内存泄漏

五、由WebView引起的内存泄漏

六、资源未关闭造成的内存泄漏

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android知识