Android内存优化(三) ——内存泄露常见情况

古城微笑少年丶 2022-05-28 23:44 276阅读 0赞

上一篇文章介绍了内存泄露的原因以及分析手段，有兴趣的同学可以先看一看[Android内存优化(二) ——内存泄露检测][Android_]

这篇文章主要介绍内存泄露的几种情况以及常用的解决方式。

#### 一、静态变量引起的内存泄漏 ####

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

##### (一)单例引起的内存泄露 #####

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也不会被释放。

##### 解决方案: #####

不要直接对 Activity 进行直接引用作为成员变量，如果允许可以使用Application。如果不得不需要Activity作为Context，可以使用弱引用WeakReference，相同的，对于Service 等其他有自己声明周期的对象来说，直接引用都需要谨慎考虑是否会存在内存泄露的可能。

##### (二)静态集合类导致的内存泄露 #####

集合类如果仅仅有添加元素的方法，而没有相应的删除机制，导致内存被占用。如果这个集合类是全局性的变量 (比如类中的静态属性，全局性的 map 等即有静态引用或 final 一直指向它)，那么没有相应的删除机制，很可能导致集合所占用的内存只增不减。

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

内部类的优势之一就是可以访问外部类，不幸的是，导致内存泄漏的原因，就是内部类持有外部类实例的强引用。  
在java里，非静态内部类 和 匿名类 都会潜在的引用它们所属的外部类。但是，静态内部类却不会。  
如果这个非静态内部类实例做了一些耗时的操作，就会造成外围对象不会被回收，从而导致内存泄漏。这类问题的解决方案为：1.将内部类变成静态内部类 2.如果有强引用Activity中的属性，则将该属性的引用方式改为弱引用。3.在业务允许的情况下，当Activity执行onDestory时，结束这些耗时任务。

##### (一) 内部线程造成的内存泄漏 #####

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();
        }
    }

##### 解决方案 #####

将非静态匿名内部类修改为静态匿名内部类

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引起的内存泄 #####

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就不会被回收。比如尤其是：mHandler.postDelayed(sRunnable, 1000 \* 60 \* 10);

##### 解决方案： #####

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，ContentObserver，FileObserver，Cursor，Callback等在 Activity onDestroy 或者某类生命周期结束之后一定要 unregister 或者 close 掉，否则这个 Activity 类会被 system 强引用，不会被内存回收。

比如我们经常会写如下代码  
![这里写图片描述][70]  
这段代码的隐患就是出现异常后导致资源无法close

##### 解决方案： #####

![这里写图片描述][70 1]

#### 四、无用监听移除 ####

##### (一) 调用了View.getViewTreeObserver().addOnXXXListener ,而没有调用View.getViewTreeObserver().removeXXXListener #####

##### (二) 传感器 #####

void registerListener() {
        SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ALL);
        sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_FASTEST);
        //这里需要在不使用的时候移除监听
    }
    
    View smButton = findViewById(R.id.sm_button);
    smButton.setOnClickListener(new View.OnClickListener(){
        @Override
        public void onClick (View v){
            registerListener();
            nextActivity();
        }
    });

#### 五、无限循环动画 ####

在Activity中播放属性动画中的一类无限循环动画，没有在ondestory中停止动画，Activity会被动画持有而无法释放

到此，常见的内存泄露就这一些了，其实简单的来说，防止内存泄露的主要就是要注意对象的声明周期的问题，Activity作为内存大户，需要更加注意。

[Android_]: http://mp.blog.csdn.net/postedit/79526394
[70]: /images/20220529/e80b894568b24f03898ed45b55d82c7f.png
[70 1]: /images/20220529/f5701d025563476f8c0a12e6e8ad5533.png