由Handler造成的内存泄漏及解决方案

本篇不再去分析Handler Looper MessageQueue 等相关源码 为了下面内容好理解可以看看我的上两篇文章
Handler消息机制
Handler Looper MessageQueue之间的协作
案例：

public class MainActivity extends AppCompatActivity {

    private Handler handler=new Handler(){
       @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
                    if(0==msg.what){
                       //xxxxxxxxxx
                 }
            }
    };

     @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handler.sendEmptyMessageDelayed(0,10*60*60*1000);
        finish();
    }
}

  public class MainActivity extends AppCompatActivity {
          @Override
          protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
                Runnable runnable=new Runnable() {
                        @Override
                        public void run() {
                         //xxxxxx
                  }
                };
          new Handler().postDelayed(runnable,10*60*60*1000);
           finish();
    }
}

上面的代码 在Handler发送延迟消息后 MainActivity就finish() ，这时Handler却持有Activity的的引用 导致Activtiy所占内存得不到释放 就造成了内存泄漏。

分析

1. 一张图看懂Handler的发送消息和处理消息的流程

   
   
   

   由上图可以看出Message全程持有发送该消息Handler的引用 直到Handler处理完消息 Message回收释放。

2. 根据上面两个案例分析 在Handler发送一个10分钟的延迟消息后 Activity就finish() 但是Handler发送的消息Message却持有Handler的引用 而Handler却是在Activtiy中创建的匿名内部类对象 在java里，非静态内部类 和 匿名类 都会潜在的引用它们所属的外部类 总结如下图：
   

   

解决方案：
1.由上分析得出是由匿名内部类隐式持有外部类 造成的内存泄漏 而在Java中静态内部类不会持有外部类对象 所以：

public class MainActivity extends AppCompatActivity {

  private static class MyHandler extends Handler {
    //WeakReference 弱引用
    private final WeakReference<MainActivity> mActivity;

    public MyHandler(SampleActivity activity) {
      mActivity = new WeakReference<MainActivity>(activity);
    }
    @Override
    public void handleMessage(Message msg) {
      MainActivity activity = mActivity.get();
      if (activity != null) {
        // ...
      }
    }
  }
  private final MyHandler mHandler = new MyHandler(this);

  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mHandler.sendEmptyMessageDelayed(0,10*60*60*1000);
        finish();
    }
}

public class MainActivity extends AppCompatActivity {
  //同理Runnable也属于匿名类部类 所以也需要声明为静态
  private static final Runnable sRunnable = new Runnable() {
      @Override
      public void run() { /* ... */ }
  };
  private final MyHandler mHandler = new MyHandler(this);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mHandler.postDelayed(runnable,10*60*60*1000);
        finish();
    }

 private static class MyHandler extends Handler {
    //WeakReference 弱引用
    private final WeakReference<MainActivity> mActivity;

    public MyHandler(SampleActivity activity) {
      mActivity = new WeakReference<MainActivity>(activity);
    }
    @Override
    public void handleMessage(Message msg) {
      MainActivity activity = mActivity.get();
      if (activity != null) {
        // ...
      }
    }
  }
}

最后：

1. 上面的案例只是用以做案例分析的 在实际开发过程中 我们必须还要在Activity或者Fragment销毁时清空消息 不然真等到消息回调的时候 Activity或Fragment已经被回收等造成其他异常情况也是不好的

@Override
    protected void onDestroy() {
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
    }

2. 如果一个内部类实例的生命周期比Activity更长，那么我们千万不要使用非静态的内部类。最好的做法是，使用静态内部类，然后在该类里使用弱引用来指向所在的Activity。