内存泄露在项目中很容易出现，但是只要细心就很容易找到，不过每一次的内存泄露查找都要耗费一定的时间，所以我们得明白什么情况下会造成内存泄露。
- 单例对象持有Activity的引用
这个我们很清楚，单例对象的生命周期可能远比Activity的生命周期长，这就说明了如果一个对象已经不需要使用了，而单例对象还持有该对象的引用，那么这个对象将不能被正常回收，这就导致了内存泄露，所以在使用单例时，我们尽可能使用application的context，而不是Activity的引用
public class AppManager{
private static AppManager instance;
private Context context;
private AppManager (Context context){
this.context =context.getApplicationContext();//getApplication重点
}
public static AppManager getInstance(Context context){
if(instance!=null){
instance =new AppManager(context);
}
return instance;
}
}
- 静态的Activity、View对象，使用静态对象造成生命周期过长导致无法释放内存。
- 非静态内部类创建静态实例造成的内存泄露
因为非静态内部类默认会持有外部类的引用，而又使用了该非静态内部类创建一个静态的实例，该实例的生命周期和应用一样长，这就是导致了该静态实例一直灰持有Activity的引用，导致Activity的内存资源不能正常回收。
public class MainActivity extends AppCompatActivity{
private static TestResource mResource =null;
@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if(mResource ==null){
mResource = new TestResuource();
}
}
static class TestResource{// static 重点
}
}
当我们不需要使用内部类的时候，如果持有了外部类的强引用，可能就会导致内存泄露，所以，我们在不需要使用内部类的时候，将其置空
+Handler的使用，上面说到了内部类，Handler的使用同样存在内存泄露，当我们在Activity中使用Handler时，持有Activity的引用时就会出现内存泄露，所以建议我们使用Handler就直接用static来修饰
错误方式
public class MainActivity extends AppCompatActivity {
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
//...
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
loadData();
}
private void loadData(){
//...request
Message message = Message.obtain();
mHandler.sendMessage(message);
}
}
这种创建Handler的方式会造成内存泄露，又要mHandler是Handler的非静态匿名内部类的实例，所以它持有外部类Activity的引用，我们知道消息队列是在一个Looper线程中不断轮询处理消息，那么当这个Activity退出时消息队列中还有未处理的消息或者正在处理消息，而消息队列这的Message持有mHandler实例的引用，mHandler又持有Activity的引用，所以导致Activity的内存资源无法及时回收，引发内存泄露。
正确方式:
创建一个静态Handler内部类，然后对Handler持有的对象使用弱引用，这样在回收时也可以回收Handler持有的对象，这样虽然避免了Activity泄露，不过Looper线程的消息队列中还是可能会有待处理的消息，所以我们在Activity的Destory时或者Stop时应该移除消息队列中的消息
public class MainActivity extends AppCompatActivity {
private MyHandler mHandler = new MyHandler(this);
private TextView mTextView ;
private static class MyHandler extends Handler {
private WeakReference reference;
public MyHandler(Context context) {
reference = new WeakReference<>(context);
}
@Override
public void handleMessage(Message msg) {
MainActivity activity = (MainActivity) reference.get();
if(activity != null){
activity.mTextView.setText("");
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView)findViewById(R.id.textview);
loadData();
}
private void loadData() {
//...request
Message message = Message.obtain();
mHandler.sendMessage(message);
}
@Override
protected void onDestroy() {
super.onDestroy();
mHandler.removeCallbacksAndMessages(null);
}
使用mHandler.removeCallbacksAndMessages(null);是移除消息队列这所以消息和所以的Runnable。当然也可以使用mHandler.removeCallbacks();或mHandler,removeMessage();来移除指定的Runnable和Message。
- 线程使用
对于线程造成的内存泄露，也是平时比较常见的，比如：
错误方式
// test 1
new AsyncTask(){
@Override
protected void doInBackground(Void... params){
SystemClock.sleep(1000);
return null;
}
}.execute();
// test 2
new Thread(new Runnable(){
@Override
public void run(){
SystemClock.sleep(10000);
}
}).start();
上面的异步任务和Runnable都是一个匿名内部类，因此它们对当前Activity都有一个隐式引用。如果Activity在销毁之前，任务还未完成，那么就会导致Activity的内存资源无法回收，造成内存泄露，正确做法还是使用静态内部类的方式：
正确方式
static class MyAsyncTask extends AsyncTask{
private WeakReference weakReference;
public MyAsyncTask(Context context){
weakReference = new WeakReference(contenxt);
}
@Override
protected void doInBackground(Void... params){
SystemClock.sleep(10000);
return null;
}
@Override
procted void onPostExecute(Void aVoid){
super.onPostExecute(aVoid);
MainActivity activity =(MainActivity) weakReference.get();
if(activity!=null){
//...
}
}
}
static class MyRunnable implements Runnable{
@Override
public void run(){
SystemClock.sleep(10000);
}
}
// 执行
new Thread(new MyRunnable()).start();
new MyAsyncTask(this).execute();
这样就避免了Activity的内存资源泄露，当然在Activity销毁的时候也应该取消相应的任务AsyncTask.cancel()，避免任务在后台执行浪费资源。
- 资源未关闭造成的内存泄露
对于使用了BraidcastReceived，ContentObserver，File，Curse，Steam，Bitmap等资源的使用，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄露。
长生命周期的对象引用短生命周期的对象，容易造成内存泄露（短生命周期的对象无法被GC回收）
检测内存泄露
- 使用LeakCanary
- AndroidStudio自带的 Android Profiler
- MAT工具
网友评论