LeakCanary源码学习一：常见内存泄漏分析

最新推荐文章于 2024-01-26 00:03:07 发布

songzi1228

最新推荐文章于 2024-01-26 00:03:07 发布

阅读量266

点赞数 1

分类专栏： Android内存相关

本文链接：https://blog.csdn.net/songzi1228/article/details/97646455

版权

Android内存相关专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1、单例造成的内存泄漏

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

3、Handler造成的内存泄漏

4、线程造成的内存泄漏

5、WebView造成的内存泄漏

来源：BAT大牛带你深度剖析Android 10大开源框架第五章

性能优化工具（九）-LeakCanary（简书，2w阅读量）

性能优化总结2：leakcanary的使用（简洁易懂）（6k阅读量）

Android 内存泄漏分析利器——leakcanary（1.4w阅读量）

Android性能优化之内存优化（自己的，详细介绍了内存泄漏情况及解决方案）

1、单例造成的内存泄漏

错误写法：

public class SingletonContext {

    private static SingletonContext mInstance;
    private Context context;

    private SingletonContext(Context context) {
        this.context = context;
    }

    public static SingletonContext getInstance(Context context) {
        if (mInstance == null) {
            mInstance = new SingletonContext(context);
        }
        return mInstance;
    }

}

这种写法，如果传入的是Activity，当这个Activity需要被销毁的时候，就会因为被单例持有引用而无法被销毁。

正确写法：

public class SingletonContext {

    private static SingletonContext mInstance;
    private Context context;

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

    public static SingletonContext getInstance(Context context) {
        if (mInstance == null) {
            mInstance = new SingletonContext(context);
        }
        return mInstance;
    }

}

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

错误写法：

public class StaticLeakActivity extends AppCompatActivity {

    private static NonStaticClass mResource = null;

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

        if (mResource == null) {
            mResource = new NonStaticClass();
        }
    }

    private class NonStaticClass {

    }
}

在这种写法里，非静态内部类NonStaticClass 会默认持有外部类StaticLeakActivity 的引用，而非静态内部类NonStaticClass又创建了一个静态实例mResource ，而这个mResource 的生命周期和APP的生命周期是一致的，这就导致StaticLeakActivity 无法被回收，从而造成内存泄漏。

正确写法：

public class StaticLeakActivity extends AppCompatActivity {

    private static NonStaticClass mResource = null;

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

        if (mResource == null) {
            mResource = new NonStaticClass();
        }
    }

    private static class NonStaticClass {

    }
}

只需要把内部类改为static就行了，这样它就不会持有外部类StaticLeakActivity的引用，这样StaticLeakActivity的内存就可以被顺利回收。

3、Handler造成的内存泄漏

Handler造成的内存泄漏是非常常见的，因为使用的多。

错误写法：

public class HandlerLeakActivity extends AppCompatActivity {

    private final Handler mLeakHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };

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

        mLeakHandler.postDelayed(new Runnable() {
            @Override
            public void run() {

            }
        },1000*60*10);

        finish();
    }

}

分析：Handler是一个TLS变量，意思就是说它的生命周期和HandlerLeakActivity 的生命周期是不一样的，这样就可能导致内存泄漏。以上代码中，我们使用mLeakHandler发送了一个延时任务，同时finish掉HandlerLeakActivity，由于执行延时任务的message还存在于主线程中，它就会持有HandlerLeakActivity中的mLeakHandler的引用（message持有mLeakHandler的引用，mLeakHandler又持有HandlerLeakActivity的引用），这种情况下finish，HandlerLeakActivity是不会被回收的。

那么，解决办法是什么呢？

1、将Handler的声明变为静态的

2、通过弱引用的方式引入Activity

3、在activity的onDestory方法中调用handler.removeCallback()

参考文章：使用Handler容易产生的内存泄露以及介绍下Java的4种引用

正确写法：

public class HandlerLeakActivity extends AppCompatActivity {

    private static class MyHandler extends Handler {
        private final WeakReference<HandlerLeakActivity> mActivity;

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

        @Override
        public void handleMessage(Message msg) {
            HandlerLeakActivity activity = mActivity.get();
            if (activity != null) {
                //...
            }
        }
    }

    private final MyHandler myHandler = new MyHandler(this);

    private static final Runnable mRunnable = new Runnable() {
        @Override
        public void run() {

        }
    };


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

        myHandler.postDelayed(mRunnable, 1000 * 60 * 10);
        finish();

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        myHandler.removeCallbacks(mRunnable);
    }
}

4、线程造成的内存泄漏

public class ThreadLeakActivity extends AppCompatActivity {

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

        testThreadLeak();
    }

    private void testThreadLeak() {
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... params) {
                SystemClock.sleep(10000);
                return null;
            }
        }.execute();

        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(10000);
            }
        }).start();

    }

    static class MyAsyncTask extends AsyncTask<Void, Void, Void> {

        private WeakReference<Context> weakReference;

        public MyAsyncTask(Context context) {
            weakReference = new WeakReference<>(context);
        }

        @Override
        protected Void doInBackground(Void... voids) {
            SystemClock.sleep(10000);
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            ThreadLeakActivity activity = (ThreadLeakActivity) weakReference.get();
            if (activity != null) {

            }
        }
    }

    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            SystemClock.sleep(10000);
        }
    }

}

方法testThreadLeak()里面的写法会造成内存泄漏，解决办法就是创建静态内部类。

5、WebView造成的内存泄漏

public class WebviewLeakActivity extends AppCompatActivity {
    private WebView mWebView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mWebView = (WebView) findViewById(R.id.wv_show);
        mWebView.loadUrl("http://www.baidu.com");
    }


    @Override
    protected void onDestroy() {
        destroyWebView();
        android.os.Process.killProcess(android.os.Process.myPid());
        super.onDestroy();
    }

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

}

songzi1228

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeakCanary源码学习一：常见内存泄漏分析

目录相关文章：1、单例造成的内存泄漏2、非静态内部类创建静态实例造成的内存泄漏3、Handler造成的内存泄漏4、线程造成的内存泄漏5、WebView造成的内存泄漏来源：BAT大牛带你深度剖析Android 10大开源框架第五章相关文章：性能优化工具（九）-LeakCanary（简书，2w阅读量）性能优化总结2：leakcanary的使用（简洁易懂）（...
复制链接

扫一扫