[关闭]
@Tyhj 2019-02-14T01:11:51.000000Z 字数 3684 阅读 509

Android常见内存泄漏分析

知识点


内存泄漏

内存泄漏就是分配的内存空间没有及时回收导致的。可使用的内存变少,应用变卡,最后内存溢出后应用就会挂掉

内存泄漏的检测

建议阅读Android内存泄漏检测和定位这篇文章,使用里面的检测方法可以轻松的验证本文中的内存泄漏例子

原因

Android内存泄漏大多是因为Activity没有被回收导致的,Activity没有被回收一般分为两种情况

  • 全局的static变量持有Activity的强引用
  • 在Activity生命周期外的线程,持有Activity的强引用

引用类型

推荐阅读Java中四种引用类型,感觉是非常容易理解的

静态变量

类中定义了静态Activity变量,把当前的Activity赋值给静态变量,如果Activity生命周期结束的时候静态变量没有清空,就会导致内存泄漏。static变量是贯穿整个应用的生命周期的,所以被泄漏的Activity就会一直存在于应用的进程中,不会被回收,同样的持有Activity(Context)的静态变量,比如View也是一样的道理

  1. private static Activity sActivity;
  2. @Override
  3. protected void onCreate(Bundle savedInstanceState) {
  4. super.onCreate(savedInstanceState);
  5. setContentView(R.layout.activity_main2);
  6. sActivity = this;
  7. findViewById(R.id.btn_back).setOnClickListener(new View.OnClickListener() {
  8. @Override
  9. public void onClick(View view) {
  10. finish();
  11. }
  12. });
  13. }

内部类

非静态内部类 和 匿名类 都会潜在的引用它们所属的外部类,但是静态内部类却不会。

  1. private static Test sTest;
  2. private static Test2 sTest2;
  3. class Test { }
  4. static class Test2 { }
  5. private void test() {
  6. sTest = new Test();
  7. sTest2=new Test2();
  8. }

屏幕快照 2019-02-13 下午1.24.04.png-110.3kB

1.如果这个非静态内部类实例内部做了一些耗时的操作,就会导致外围对象不会被回收,从而导致内存泄漏

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

这个匿名内部类会引用这个Activity,内部开了线程做耗时操作,就会导致这个Activity不能被回收

2.结合上面的静态变量,如果静态变量持有非静态内部类的引用,而
非静态内部类引用了该Activity,那就会导致这个Activity不能被回收

  1. private static Test sTest;
  2. class Test {}
  3. private void test() {
  4. sTest = new Test();
  5. }
  6. @Override
  7. protected void onCreate(Bundle savedInstanceState) {
  8. super.onCreate(savedInstanceState);
  9. setContentView(R.layout.activity_main);
  10. test();
  11. }

Test是非静态内部类,sTest是静态变量,注意这个静态变量是在onCreate中初始化的,会持有该Activity的引用,Activity被销毁的时候sTest不置空那么该Activity就无法被回收;

内部类常见情况

上面都说了,非静态内部类会引用所属外部类,这时候如果创建一个内部类,而且持有一个静态变量的引用就容易会引起外部类没法被回收;同样的如果该内部类在子线程做了一些耗时操作,属于在Activity生命周期外的线程,也会导致外部类没法被回收;常见的情况有下面几种

Threads

上面第一个例子已经写过了

TimerTask

匿名内部类嘛,肯定就持有所在Activity的引用,又做耗时操作,肯定内存泄漏

Handler

一个道理,匿名内部类嘛,肯定就持有所在Activity的引用,如果执行postDelayed的时候,Activity被销毁,那么Handler持有的Activity没法被回收,就内存泄漏了,而且里面也有一个匿名内部类Runnable持有Activity

  1. new Handler(){
  2. @Override
  3. public void handleMessage(Message msg) {
  4. super.handleMessage(msg);
  5. }
  6. }.postDelayed(new Runnable() {
  7. @Override
  8. public void run() {
  9. }
  10. },10000);

系统服务

这个也很好理解,当你使用系统服务的时候,可以注册监听器,会导致服务持有Context的引用,如果在Activity销毁的时候,没有注销掉监听器,就会导致内存泄漏;

  1. //传感器的监听器注册
  2. SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
  3. Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ALL);
  4. sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_FASTEST);

注册广播接收器也是需要在onDestroy方法里面注销

资源未释放

这个简单,一般就各种流、各种资源没有关闭,集合中对象没清理导致,倒是不容易犯错

静态内部类解决内存泄漏

1.静态内部类不会持有外部类的引用,所以使用静态内部类可以解决以上问题,如果静态内部类里面需要引用外部类,可以通过弱引用的方式来引用;
2.用static的变量引用匿名内部类的实例或将匿名内部类的实例化操作放到外部类的静态方法中

  1. //静态内部类
  2. private static class Myhandler extends Handler {
  3. private final WeakReference<Activity> mActivity;
  4. public Myhandler(Activity activity) {
  5. mActivity = new WeakReference<Activity>(activity);
  6. }
  7. @Override
  8. public void handleMessage(Message msg) {
  9. super.handleMessage(msg);
  10. Activity activity = mActivity.get();
  11. // ...
  12. }
  13. }
  14. private final Myhandler mMyhandler=new Myhandler(this);
  15. //这样写不会持有外部类的引用
  16. private static final Runnable sRunnable = new Runnable() {
  17. @Override
  18. public void run() { /* ... */ }
  19. };
  20. @Override
  21. protected void onCreate(Bundle savedInstanceState) {
  22. super.onCreate(savedInstanceState);
  23. setContentView(R.layout.activity_main);
  24. mMyhandler.postDelayed(sRunnable, 1000 * 60 * 10);
  25. }

方法没有问题,但是为什么上面的写法sRunnable没有引用外部类而下面的写法会引用呢,会导致内存泄漏呢;我觉得是因为初始化的位置不同,静态变量和静态类先被初始化了,所以没有外部类的引用;感觉是这样的吧

  1. private static Runnable sRunnable;
  2. @Override
  3. protected void onCreate(Bundle savedInstanceState) {
  4. super.onCreate(savedInstanceState);
  5. setContentView(R.layout.activity_main);
  6. sRunnable = new Runnable() {
  7. @Override
  8. public void run() { /* ... */ }
  9. };
  10. }

参考文章:

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注