Android 面试题内存泄露的原因二

🔥 什么是内存泄漏 🔥

在Android开发过程中，当一个对象已经不需要再使用了，本该被回收时，而另个正在使用的对象持有它引用从而导致它不能被回收，这就导致本该被回收的对象不能被回收而停留在堆内存中，内存泄漏就产生了。

它是造成应用程序OOM的主要原因之一；由于Android系统为每个应用程序分配的内存有限，当一个应用中产生的内存泄漏比较多时，就难免会导致应用所需要的内存超过系统分配的内存限额，这就造成了内存泄漏而导致应用Crash；

🔥 内存泄漏排查使用adb命令 🔥

使用adb命令 查看当前activity数量。不停打开关闭要排查页面，由于关闭页面后垃圾回收不会立即执行，为了测试，借助Android Studio自带的 Profiler，点击强制垃圾回收。若activiy数量和最开始时一致，则表示正常，若activity数量增加，则表明内存泄漏。
adb shell dumpsys meminfo 包名

🔥 内存泄漏排查使用Profiler 🔥

使用AS中Profiler进一步问题排查，点击Dump Java heap导出堆分配。

🔥 静态Activity和View 造成内存泄漏 🔥

静态Activity(Activity上下文Context)和View

静态变量Activity和View会导致内存泄漏，在下面代码中对Activity的Context和TextView设置为静态对象，从而产生内存泄漏；
因为context和textView的实例的生命周和应用的生命一样，而他们持有当前Activity(MemoryTestActivity)的引用，一旦MemoryTestActivity销毁，而他的引用一直持有，就不会被回收，所以产生内存泄漏了；
public class MemoryTestActivity extends AppCompatActivity {private static Context context;private static TextView textView;@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState){super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);context = this;textView = new TextView(this);}
}

🔥 单例造成的内存泄漏 🔥

单例造成的内存泄漏

Android的单例模式是开发中经常使用的模式，使用不恰当可能导致内存泄漏；单例的生命周期和应用的生命周期一样，也就是单例持有必须是和应用生命周期一样的对象，不能持有和应用生命周期不一致的对象例如：Activity(Context)上下文：
public class TestManager {private static TestManager manager;private Context context;private TestManager(Context context) {this.context = context;}/*** 如果传入的context是activity,service的上下文，会导致内存泄漏* 原因是我们的manger是一个static的静态对象，这个对象的生命周期和整个app的生命周期一样长* 当activity销毁的时候，我们的这个manger仍然持有者这个activity的context，* 就会导致activity对象无法被释放回收，就导致了内存泄漏*/public static TestManager getInstance(Context context) {if (manager == null) {manager = new TestManager(context);}return manager;}
}

解决方法：

修改TestManager单例模式使用的上下文Context，TestManager单例模式引用ApplicationContext，TestManager单例模式和应用生命周期一样，ApplicationContext和应用的生命周期是一样，这样不会出现内存泄漏；
public class TestManager {private static TestManager manager;private Context context;private TestManager(Context context) {this.context = context;}//正确写法public static TestManager getInstance(Context context) {if (manager == null) {manager = new TestManager(context.getApplicationContext());}return manager;}
}

🔥 线程造成的内存泄漏 🔥

匿名线程内部类会隐式引用Activity，当执行耗时任务时，一直隐式引用Activity，当Activity关闭时，由于匿名线程内部类会隐式引用Activity无法及时回收；

public class MemoryTestActivity extends AppCompatActivity {@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState{super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);anonymousInnerClass();}//匿名内部类持有MemoryTestActivity实例引用，当耗时匿名线程内部类执行完成以后        //MemoryTestActivity实例才会回收；public void anonymousInnerClass() {new AsyncTask<Void, Void, Void>(){@Overrideprotected Void doInBackground(Void... voids) {//执行异步处理        SystemClock.sleep(120000);return null;}}.execute();}
}

解决方法：

修改AsyncTask匿名内部类为静态类，解除Activity隐式引用，MemoryTestActivity销毁时要及时取消异步任务staticAsyncTask.cancel(true)，防止异步任务执行完成更新销毁MemoryTestActivity实例的UI;

public class MemoryTestActivity extends AppCompatActivity {private StaticAsyncTask staticAsyncTask;@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);staticAsyncTask = new StaticAsyncTask(this);staticAsyncTask.execute();}private static class StaticAsyncTask extends AsyncTask<Void, Void, Void> {private WeakReference<Context> weakReference;public StaticAsyncTask(Context context) {weakReference = new WeakReference<Context>(context);}@Overrideprotected Void doInBackground(Void... voids) {//执行异步处理            SystemClock.sleep(120000);return null;}@Overrideprotected void onPostExecute(Void aVoid) {super.onPostExecute(aVoid);MemoryTestActivity activity = (MemoryTestActivity) weakReference.get();if (activity != null) {//异步任务执行完成，执行UI处理}}}@Overrideprotected void onDestroy() {super.onDestroy();staticAsyncTask.cancel(true);}
}

🔥 非静态内部类创建静态实例造成的内存泄漏 🔥

这样就在Activity内部创建了一个非静态内部类的单例，每次启动Activity时都会使用该单例的数据，这样虽然避免重复创建，不过这种写法会造成内存泄漏，因为非静态内部类默认会持有外部类的引用，而又使用了该非静态内部类创建了一个静态实例，该实例的生命周期和应用一样长，这就导致了该静态实例一直持有该Activity的引用，导致Activity的内存资源不能正常回收；
public class MemoryTestActivity extends AppCompatActivity {private static TestResource testResource;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);testResource = new TestResource();}class TestResource{//资源类}
}

解决方法：

将该内部类设为静态内部类或将内部类抽象出来封装一个单例，如果需要使用Context，请使用ApplicationContext；

🔥 Handler造成的内存泄漏 🔥

Handler的使用造成的内存泄漏问题是比较常见的，平时处理网络任务或者封装一些请求回调等api都应该会借助Handler处理，对于Handler的使用代码不规范可能会造成内存泄漏，如下示例：
private Handler mHandler = new Handler(){@Overridepublic void handleMessage(Message msg) {//处理UI显示}
};@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);loadData();}//loadData()方法在子线程中执行private void loadData() {Message message = Message.obtain();//模拟线程延迟120秒发送        MessagemHandler.sendMessageDelayed(message, 120000);}
}

这种创建Handler的方式可能造成内存泄漏，由于mHandler是Handler的非静态匿名内部类的实例，所以它持有外部类Activity引用，我们知道消息队列是在一个Looper线程中不断轮询处理消息，那么当这个Activity退出时，消息队列还有未处理的消息或者正在处理的消息（例如上面的例子，子线程中处理耗时任务，还没有执行完毕，activity就退出销毁），而消息队列中Message持有mHandler实例引用，mHander又持有Activity的引用，所以导致Activity的内存无法及时回收，引发内存泄漏；
public class MemoryTestActivity extends AppCompatActivity {private Handler handler = new StaticHandler(this);private static class StaticHandler extends Handler {WeakReference<Context> weakReference;public StaticHandler(Context context) {weakReference = new WeakReference<>(context);}@Overridepublic void handleMessage(Message msg) {//处理UI显示MemoryTestActivity activity = (MemoryTestActivity) weakReference.get();if (activity != null) {}}
}@Override
protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);loadData();
}
//loadData()方法在子线程中执行
private void loadData() {Message message = Message.obtain();//模拟线程延迟120秒发送Messagehandler.sendMessageDelayed(message, 120000);
}
@Override
protected void onDestroy() {super.onDestroy();handler.removeCallbacksAndMessages(null);}
}
创建一个静态Handler内部类，然后对Handler持有的对象使用弱应用，这样在回收时也可以回收Handler持有的对象，这样避免了Activity泄漏，如果Handler被delay(延迟执行)，在Activity的Destroy或者Stop时应该移除消息队列中的消息；
handler.removeCallbacksAndMessages(null);移除消息队列中所有的消息和线程；

解决方案一 : 通过程序逻辑来进行维护

在关闭Activity的时候停掉后台线程；线程停掉相当于切断了Handler和外部连接线，Activity自然会被在合适的时候回收；

如果Handler被delay延迟的Message持有了引用，那么使用相应的Handler的removeCallbacks()方法，把消息对象从消息队列移除就行；

解决方案二 : 将Handler声明为静态类

在Java中，非静态的内部类和匿名内部类都会隐式持有其外部类的引用，静态内部类不会持有外部类的引用。静态类不持有外部类的对象，所以你的Activity可以随意被回收；由于Handler不在持有外部类的对象的引用，导致程序不允许你在Handler中操作Activity中的对象了，所以你需要在Handler中增加一个对Activity的弱引用(WeakReference);

🔥 动画造成内存泄露 🔥

在属性动画中有一类无限循环动画，如果在Activity中播放这类动画并且在onDestroy()中没有去停止动画，那么动画会一直播放下去，这时候Activity会被View所持有，从而导致Activity无法被释放。解决此类问题要在onDestroy()方法中去调用objectAnimator.cancel()来停止动画；
public class MemoryTestActivity extends AppCompatActivity {private TextView textView;private ObjectAnimator objectAnimator;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_memory_test);textView = (TextView)this.findViewById(R.id.textView2);objectAnimator = ObjectAnimator.ofFloat(textView, "rotation", 0, 360);objectAnimator.setRepeatCount(ValueAnimator.INFINITE);objectAnimator.start();}@Overrideprotected void onDestroy() {super.onDestroy();}
}
由于未在onDestroy()方法中去调用objectAnimator.cancel()来停止动画，执行动画的View一直引用Activity，导致Activity无法销毁；

解决办法：

在onDestroy()方法中去调用objectAnimator.cancel()来停止动画；

🔥 第三方库使用不当造成内存泄露 🔥

1、对于EventBus，RxJava等一些第三方开源框架的使用，若是Activity销毁之前没有进行解除订阅会导致内存泄漏；
2、需要在生命周期相对注册与注销（onCreate->onDestory | onResume->onPause … ）

3、资源未关闭造成的内存泄漏

对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源的使用，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄漏。