Analyses of Memory Leak

Posted on | In | | Visitors

测试工具：LeakCanary

1
2
debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5'
releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'

内存泄漏的主要问题可以分为以下几种类型：

  1. 静态变量引起的内存泄漏
  2. 非静态内部类引起的内存泄漏

  3. 资源未关闭引起的内存泄漏

    静态变量引起的内存泄漏

    在Java中静态变量的生命周期是在类加载时开始，类卸载时结束。换句话说，在Android中其生命周期是在进程启动时开始，进程死亡时结束。所以在程序的运行期间，如果进程没有被杀死，静态变量就会一直存在，不会被回收掉。如果静态变量强引用了某个Activity中变量，那么这个Activity就同样也不会被释放,即便是该Activity执行了onDestroy(不要将执行onDestroy和被回收划等号)。 这类问题的解决方案为：1.寻找与该静态变量生命周期差不多的替代对象。2.若找不到，将强引用方式改成弱引用。

    单例引起的Context内存泄漏

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
     public class IMManager {
        private Context context;
        private static IMManager mInstance;
        public static IMManager getInstance(Context context) {
            if (mInstance == null) {
                synchronized (IMManager.class) {
                    if (mInstance == null)
                        mInstance = new IMManager(context);
                }
            }
            return mInstance;
        }
        private IMManager(Context context) {
            this.context = context;
        }
    }

当调用getInstance时，如果传入的context是Activity的context。只要这个单例没有被释放，这个Activity也不会被释放。

解决方案
传入Application的context,因为Application的context的生命周期比Activity长，可以理解为Application的context与单例的生命周期一样长，传入它是最合适的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class IMManager {
    private Context context;
    private static IMManager mInstance;
    public static IMManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (IMManager.class) {
                if (mInstance == null)
                    //将传入的context转换成Application的context
                    **mInstance = new IMManager(context.getApplicationContext());**
            }
        }
        return mInstance;
    }
    private IMManager(Context context) {
        this.context = context;
    }
}

非静态内部类引起的内存泄漏

在java中，创建一个非静态的内部类实例，就会引用它的外围实例。如果这个非静态内部类实例做了一些耗时的操作，就会造成外围对象不会被回收，从而导致内存泄漏。这类问题的解决方案为：1.将内部类变成静态内部类 2.如果有强引用Activity中的属性，则将该属性的引用方式改为弱引用。3.在业务允许的情况下，当Activity执行onDestory时，结束这些耗时任务。

内部线程造成的内存泄漏

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
public class LeakAty extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_leak);
        test();
    }
    public void test() {
        //匿名内部类会引用其外围实例LeakAty.this,所以会导致内存泄漏
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
    }

解决方案
将非静态匿名内部类修改为静态匿名内部类

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
public class LeakAty extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_leak);
        test();
    }
    //**加上static，变成静态匿名内部类**
    public static void test() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

Handler引起的内存泄漏

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
public class LeakAty extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_leak);
        fetchData();
    }
    private Handler mHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case 0:
                // 刷新数据
                break;
            default:
                break;
            }
        };
    };
    private void fetchData() {
        //获取数据
        mHandler.sendEmptyMessage(0);
    }

mHandler 为匿名内部类实例，会引用外围对象LeakAty.this,如果该Handler在Activity退出时依然还有消息需要处理，那么这个Activity就不会被回收。

解决方案

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
public class LeakAty extends Activity {
    private TextView tvResult;
    private MyHandler handler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_leak);
        tvResult = (TextView) findViewById(R.id.tvResult);
        handler = new MyHandler(this);
        fetchData();
    }
    //第一步，将Handler改成静态内部类。
    private static class MyHandler extends Handler {
        //第二步，将需要引用Activity的地方，改成弱引用。
        private WeakReference<LeakAty> atyInstance;
        public MyHandler(LeakAty aty) {
            this.atyInstance = new WeakReference<LeakAty>(aty);
        }
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            LeakAty aty = atyInstance == null ? null : atyInstance.get();
            //如果Activity被释放回收了，则不处理这些消息
            if (aty == null||aty.isFinishing()) {
                return;
            }
            aty.tvResult.setText("fetch data success");
        }
    }
    private void fetchData() {
        // 获取数据
        handler.sendEmptyMessage(0);
    }
    @Override
    protected void onDestroy() {
        //第三步，在Activity退出的时候移除回调
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
    }
}

资源未关闭引起的内存泄漏

当使用了BraodcastReceiver、Cursor、Bitmap等资源时，当不需要使用时，需要及时释放掉，若没有释放，则会引起内存泄漏。

参考阅读

Android进程的内存管理分析
Android内存泄漏终极解决篇（上）
Android内存泄漏终极解决篇（下）