Android

[Android]面试相关-内存泄露

2019-11-02  本文已影响0人  Merbng

内存泄露在项目中很容易出现，但是只要细心就很容易找到，不过每一次的内存泄露查找都要耗费一定的时间，所以我们得明白什么情况下会造成内存泄露。

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

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()，避免任务在后台执行浪费资源。

检测内存泄露

上一篇下一篇

猜你喜欢

热点阅读