Handler机制详解

ITJL博客

一、什么是Handler机制

定义：

Handler是用来结合线程的消息队列来发送、处理"Message对象"和"Runnable对象"的工具。

通常的来说，就是我们在线程之间处理消息通知及任务调度的工具。

二、Handler机制原理

先捋一遍源码，画个时序图，然后等下逐一说明。

image-20210115163424214

• 相关类

  Handler机制的实现离不开与之相关的其他三个类，Message是Handler发送的消息实体，大部分的消息都是通过Message来封装传递的；MessageQueue是用来将消息按顺序排队的队列；Looper本质就是一个循环，不停的从MessageQueue中取出消息然后处理。

• 执行过程

  首先，如上图所示任务的开始是由创建一个Message开始的，Message创建完毕后交给Handler对象发送，sendMessage和sendMessageDelay最终都是在底层调用了sendMessageAtTime()方法，将Message对象放入MessageQueue中的。

  之后，由Looper的loop()方法循环从MessageQueue中取出Message对象，调用message.getTarget ()获取到发送消息的Handler对象，然后再调用handler.dispatchMessage()方法将信息分发给对应handler执行。

  最后，Handler在dispatchMessage()方法中判断是否有callback 存在，存在则执行callback的onMessageHandler()，最终交由Message.callback执行；否则则执行handler的onMessageHandler()方法。

  
  public interface Callback {// callback接口
      public boolean handleMessage(Message msg);
  }
  
  public void handleMessage(Message msg) {
  
  }
  
  public void dispatchMessage(Message msg) {
      if (msg.callback != null) {
          /* 
          * callback是msg中的一个字段，是一个Runnable对象，
          * 当通过handler.post方法发送一个runnable的时候就会被封装到这个msg中
          */
          handleCallback(msg); 
          /*
          * 此方法是Handler中的一个静态方法，方法体：message.callback.run();
          * 只有这一句，可以看出是直接调用的run()方法，没有新建线程，
          * 否则也不符合这里线程通信了。
          */
      } else {
          if (mCallback != null) { // mCallback就是上面接口的对象
              if (mCallback.handleMessage(msg)) {
                  /*
                  * 如果返回true直接return结束方法，
                  * 不再调用handler中的handleMessage方法。
                  */
                  return;
              }
          }
          handleMessage(msg);// handler中的消息处理方法
      }
  }   
  
  

三、其他的相关问题

1. 一个线程几个 Looper，几个 Handler，Looper 如何确定是哪个 Handler？

   一个线程只有一个Looper来处理MessageQueue中的消息；Handler可以有多个，用来发送及处理消息。Looper不需要确定是那个Handler发送过来的消息，因为Message有个targ字段封装了发送他的handler,系统直接通过message.getTarg().hanldMessage();就可以调用到handler的处理消息方法。

2. 两个均不是主线的线程如何用Handler通信

   在阐述这个问题时难免又要回到Handler的机制说明上；线程间的通信关键是Handler的创建，而Handler的创建本质需要一个Looper对象的存在。

   Android默认在主线程中初始化了一个Looper（详见android.app.ActivityThread->Looper.prepareMainLooper()），其他线程都需要自己手动创建Looper；一个线程能够使用Handler处理消息，是必须要有Looper和MessageQueue的。

   下面回到具体问题，两个都不是主线程的线程需要通过Handler通信改如何操作？根据上面的分析我们知道：

   1. 需要在处理逻辑的线程Thread1创建Looper，有了Looper之后才能创建Handler；
   2. 之后在需要发消息的线程Thread2使用Thread1的handler对象发送Message；

   有了理论，之后撸一把代码：

   
   public class MainActivity extends ComponentActivity {
       private static final String TAG = "MainActivity";
       private Looper looper2;
       private Thread1 thread1;
       private Thread thread2;
       private Handler child1Handler, child2Handler;
   
       @Override
       protected void onCreate(@Nullable Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           initView();
       }
   
       private void initView() {
           setContentView(R.layout.activity_main);
           thread1 = new Thread1("ChildThread1");
           thread2 = new Thread2("ChildThread2");
           thread1.start();
           thread2.start();
       }
   
       private void initHandler() {
           child1Handler = new Handler(thread1.getLooper()) {
               @Override
               public void handleMessage(@NonNull Message msg) {
                   String ms = (String) msg.obj;
                   Log.e(TAG, "当前线程：" + Thread.currentThread().getName() + "  消息：" + ms);
                   try {
                       Thread.sleep(1500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   Message message = Message.obtain();
                   message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
                   child2Handler.sendMessage(message);
               }
           };
   
           child2Handler = new Handler(looper2) {
               @Override
               public void handleMessage(@NonNull Message msg) {
                   String ms = (String) msg.obj;
                   Log.w(TAG, "当前线程：" + Thread.currentThread().getName() + "  消息：" + ms);
                   try {
                       Thread.sleep(1500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   Message message = Message.obtain();
                   message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
                   child1Handler.sendMessage(message);
               }
           };
       }
   
       class Thread1 extends HandlerThread {
           public Thread1(String name) {
               super(name);
           }
       }
   
       class Thread2 extends Thread {
           public Thread2(String name) {
               super(name);
           }
   
           @Override
           public void run() {
               Looper.prepare();
               looper2 = Looper.myLooper();
               initHandler();
               Message message = Message.obtain();
               message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
               child2Handler.sendMessage(message);
               Looper.loop();
           }
       }
   }
   
   

四、Handler的内存泄露

Handler是引发内存泄露的大户，其根源还是在于Handler机制的设计结构上；

1. 原因：

   Message对象必须持有一个Handler的引用才能顺利分发任务。而如果Message在MessageQueue中不能及时被取出执行，则会导致MessageQueue长时间的持有Message对象；一般情况下我们会在Activity中以内部类的形式创建Handler；这就导致了一系列的连锁反应：

   Activity 被 Handler持有，Handler被Message持有，Message被MessageQueue持有，MessageQueue中任务积压，或者是本来就是个延时任务；这就导致了内存溢出。

2. 解决办法：

   根据上述的原因我们只需要能在Handler和Activity之间断开联系，既能保证内存不再泄露；

   1）内部类是在类对象创建后作为对象的一个成员存在的，而静态内部类则是在类class文件加载时就创建了，不再与外部类对象关联；因此我们可以将handler声明为静态内部类。

   2）我们都知道Hander还有个内部接口Callback和与之对应的构造函数Handler(Callback callback)；

   
   /**
    * 实现回调弱引用的Handler
    * 防止由于内部持有导致的内存泄露 
    * 传入的Callback不能使用匿名实现的变量，必须与使用这个Handle的对象的生命周期一致，
    * 否则会被立即释放掉了
    */
   public class WeakRefHandler extends Handler {
       private WeakReference mWeakReference;
   
       public WeakRefHandler(Callback callback) {
           mWeakReference = new WeakReference(callback);
       }
   
       public WeakRefHandler(Callback callback, Looper looper) {
           super(looper);
           mWeakReference = new WeakReference(callback);
       }
   
       @Override
       public void handleMessage(Message msg) {
           if (mWeakReference != null && mWeakReference.get() != null) {
               Callback callback = mWeakReference.get();
               callback.handleMessage(msg);
           }
       }
   }
   
   

   接下来就是使用，由于是弱引用，当该类需要被回收时，就可以直接被回收掉：

   
   private Handler.Callback mCallback = new Handler.Callback() {
       @Override
       public boolean handleMessage(Message msg) {
           switch(msg.what){
              return true;
           }
       };
   private Handler mHandler = new WeakRefHandler(mCallback);
   
   

ITJL博客