十一、性能优化–内存泄漏

十一、性能优化–内存泄漏

留下评论

背景：Android系统分配给每个应用程序的内存有限
内存泄漏的定义：本该被回收的对象不能被回收而停留在堆内存中
内存泄漏的原因：当一个对象已经不再被使用时，本该被回收但却因为另外一个正在使用的对象持有它的引用从而导致它无法被回收
内存泄漏导致的后果：会使应用崩溃

人为原因：无意识地持有对象引用，使得持有引用者的生命周期>被引用者的生命周期

原理：程序在申请内存后，当该内存不需使用但却无法被释放以及归还给程序的现象

Java垃圾回收器（GC）的内存释放 = 垃圾回收算法

分代收集算法

算法思路：

  1. 根据对象存活周期的不同将Java堆内存分为：新生代和老年代
  2. 每块区域特点：
    新生代：对象存活率较低与垃圾回收行为频率高（朝生夕灭的对象，比如方法的局部变量）
    老年代：对象存活率较高与垃圾回收行为频率低 (存活得比较久，但还是要死的对象，如类的成员变量)

3.新生代：采用复制算法，老年代：采用标记-清除、标记-整理算法
还有永久代：在方法区

常见的内存泄漏原因与解决方案

  1. 集合类
  2. Static关键字修饰的成员变量
  3. 非静态内部类/匿名类
  4. 资源对象使用后未关闭

集合类

泄漏原因：集合添加了某个对象，当对象为null时，因为集合仍引用着该对象，会导致该对象没法被回收，从而导致内存泄漏
示例代码：

// 通过 循环申请Object 对象 & 将申请的对象逐个放入到集合List
List objectList = new ArrayList();
   for (int i = 0; i

解决方案：集合不再用时，清空集合对象 & 设置为null
示例代码：
objectList.clear();
objectList=null;

Static 关键字修饰的成员变量

背景：被Static关键字修饰的成员变量的生命周期=应用程序的生命周期
如Activity的context传给Static的成员变量
典型案例：单例模式
泄漏原因：
若1个对象已不需再使用 而单例对象还持有该对象的引用，那么该对象将不能被正常回收 从而 导致内存泄漏
示例错误单例代码：

// 创建单例时，需传入一个Context
// 若传入的是Activity的Context，此时单例 则持有该Activity的引用
// 由于单例一直持有该Activity的引用（直到整个应用生命周期结束），即使该Activity退出，该Activity的内存也不会被回收
// 特别是一些庞大的Activity，此处非常容易导致OOM

public class SingleInstanceClass {
    private static SingleInstanceClass instance;
    private Context mContext;
    private SingleInstanceClass(Context context) {
    this.mContext = context; // 传递的是Activity的context
}  
  
public SingleInstanceClass getInstance(Context context) {
    if (instance == null) {
        instance = new SingleInstanceClass(context);
        }
    return instance;
    }
}

解决方案：应传递Application的Context，因Application的生命周期 = 整个应用的生命周期

非静态内部类 / 匿名类

根本原理： 非静态内部类 / 匿名内部类，运行时默认持有外部类的引用

泄露原因：若 非静态内部类所创建的实例 = 静态（其生命周期 = 应用的生命周期），会因 非静态内部类默认持有外部类的引用 而导致外部类无法释放，最终 造成内存泄露
即 外部类中 持有 非静态内部类的静态对象
示例代码：

    // 背景：
   a. 在启动频繁的Activity中，为了避免重复创建相同的数据资源，会在Activity内部创建一个非静态内部类的单例
   b. 每次启动Activity时都会使用该单例的数据

public class TestActivity extends AppCompatActivity {  

// 非静态内部类的实例的引用
// 注：设置为静态  
public static InnerClass innerClass = null; 
   
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);   

// 保证非静态内部类的实例只有1个
if (innerClass == null)
innerClass = new InnerClass();
}

// 非静态内部类的定义
private class InnerClass {
//...
}
}

// 造成内存泄露的原因：
// a. 当TestActivity销毁时，因非静态内部类单例的引用（innerClass）的生命周期 = 应用App的生命周期、持有外部类TestActivity的引用
// b. 故 TestActivity无法被GC回收，从而导致内存泄漏

解决方案：

  1. 将非静态内部类设置为：静态内部类（静态内部类默认不持有外部类的引用）
  2. 尽量 避免 非静态内部类所创建的实例 = 静态

多线程：AsyncTask、实现Runnable接口、继承Thread类

泄漏原因：
当 工作线程正在处理任务 & 外部类需销毁时， 由于 工作线程实例 持有外部类引用，将使得外部类无法被垃圾回收器（GC）回收，从而造成 内存泄露
泄漏示例代码：

 /** 
 * 方式1：新建Thread子类（内部类）
 */  
public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

// 通过创建的内部类 实现多线程
new MyThread().start();

}
// 自定义的Thread子类
private class MyThread extends Thread{
@Override
public void run() {
try {
Thread.sleep(5000);
Log.d(TAG, "执行了多线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

   /** 
 * 方式2：匿名Thread内部类
 */ 
 public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

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

// 通过匿名内部类 实现多线程
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
Log.d(TAG, "执行了多线程");
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}.start();
}
}


/** 
  * 分析：内存泄露原因
  */ 
  // 工作线程Thread类属于非静态内部类 / 匿名内部类，运行时默认持有外部类的引用
  // 当工作线程运行时，若外部类MainActivity需销毁
  // 由于此时工作线程类实例持有外部类的引用，将使得外部类无法被垃圾回收器（GC）回收，从而造成 内存泄露

其他：对Context的引用不要超过它本身的生命周期

参考：https://www.jianshu.com/nb/21401973