Android 内存泄漏问题
newInstance 里传入一个 context，这个 context 一般是 Activity 的上下文，这就形成了该单例模式持有一个 activity 的强引用一直到整个应用的生命周期结束。这样的话，即是该 Activity 退出，该 Activity 的内存也不会被回收，如果该 Activity 内存很大，还会造成 OOM，这就很 mmp 了。
解决方法是让单例模式引用的对象的生命周期=应用的生命周期
没错，就是传入 applicationContext 啦！
public class SingleInstance {
private static SingleInstance sInstance;
private Context mContext;
private SingleInstance(Context context){
this.mContext = context.getApplicationContext();
}
public static SingleInstance newInstance(Context context){
if(sInstance == null){
sInstance = new SingleInstance(context);
}
return sInstance;
}
}
让单例模式持有 activity 的 ApplicationContext，application 的生命周期就是应用的生命周期。这样就不会导致内存泄漏。
注：我们平时在传入 ActivityContext 的地方会直接传入 Activity.this，如果处理这个 context 的类处理不好也会造成内存泄漏，这时候可以使用弱引用，每次 GC 的时候都会将其回收。
public class Sample {
private WeakReference<Context> mWeakReference;
public Sample(Context context){
this.mWeakReference = new WeakReference<>(context);
}
public Context getContext() {
if(mWeakReference.get() != null){
return mWeakReference.get();
}
return null;
}
}
// 外部调用
Sample sample = new Sample(MainActivity.this);
2. 非静态内部类/匿名类
接下来看看静态和非静态内部类的区别
| class 对比 | 静态内部类 | 非静态内部类 |
| --- | --- | --- |
| 与外部类的关系 | 如果没有参数传入就没有引用关系 | 自动获得强引用 |
| 被调用时需要外部实例 | 不需要 | 需要 |
| 能否调用外部类中的变量和方法 | 不能 | 能 |
| 生命周期 | 自主的生命周期 | 依赖于外部类，甚至可能比外部类更长 |
可以看出非静态内部类自动获得外部类的强引用，而且它的生命周期甚至比外部类更长，这便埋下了内存泄露的隐患。如果一个 A
ctivity 的非静态内部类的生命周期比 Activity 更长，那么 Activity 的内存便无法被回收，也就是发生了内存泄露，而且还有可能发生难以预防的空指针问题。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new MyAscnyTask().execute();
}
class MyAscnyTask extends AsyncTask<Void, Integer, String>{
@Override
protected String doInBackground(Void... params) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "";
}
}
}
我们在 Activity 中继承 AsyncTask，并开启了其非静态内部类方法 doInbackground() 方法，在其中做了耗时的操作，然后在 onCreate() 中启动 MyAsyncTask。如果在耗时操作结束之前，Activity 被销毁了，这时候因为 MyAsyncTask 持有 Activity 的强引用，便会导致 Activity 的内存无法被回收，这时候便会产生内存泄露。
解决方法：根据静态内部类和非静态内部类的区别，我们将其转化为静态内部类，这样子就不再持有 Activity 的强引用，Activity 就可以在做耗时操作的时候可以安全退出。
匿名类和非静态内部类共同点就是 都持有外部类的强引用，
public class MainActivity extends AppCompatActivity {
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// ① 匿名线程持有 Activity 的引用，进行耗时操作
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(50000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
// ② 使用匿名 Handler 发送耗时消息
Message message = Message.obtain();
mHandler.sendMessageDelayed(message, 60000);
}
上面是最常见的两个造成内存泄漏的例子
（1）在 Thread 中的匿名内部类 Runnable 中做耗时操作
（2）在 Handler 中做延迟发送
如果上述两种情况执行时 Activity 退出，就会产生内存泄漏
解决方法：继承 Thread 实现其静态内部类\继承 Handler 实现其静态内部类并且在 Activity 的 onDestroy（）中移除所有消息 mHandler.removeCallbacksAndMessages(null)
3. 集合类
集合类添加元素后，仍引用着集合元素对象，导致该集合中的元素对象无法被回收，从而导致内存泄露，举个例子：
static List<Object> objectList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
Object obj = new Object();
objectList.add(obj);
obj = null;
}
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论