Android 之 “只是想来谈谈 Handler 机制”

左手的ㄟ右手 2022-04-27 19:36 129阅读 0赞

> 《Android之“只是想来谈谈Handler机制”》  
> 转载请注明来自 [傻小孩b][b]（[gold.xitu.io/user/57e089…][b]喜欢的可以关注我，不定期总结文章！您的支持是我的动力哈！

## 前言 ##

在谈Handler的时候，应该会涉及到三个角色：**Handler自身**、**Looper**、**MessageQueue**。这里我将一一做分析记录：

### Looper ###

Looper类代码并不长，所以相对消化起来并不是特别的难。  
Looper是一种循环机制，而且保证每个线程只能存在一个Looper机制。  
讲到Looper，如果要从头开始认识这个机制，当然要参考应用的主线程main函数入口，**ActivityThread**。代码：

public static void main(String[] args) {
           ...
            Looper.prepareMainLooper(); 
       ...
         Looper.loop();
     }复制代码

再往里面看 **Looper.prepareMainLooper()**;

public static void prepareMainLooper() {
            prepare(false);
            synchronized (Looper.class) {
                if (sMainLooper != null) {
                    throw new IllegalStateException("The main Looper has already been prepared.");
                }
                sMainLooper = myLooper();
            }
        }
    
    private static void prepare(boolean quitAllowed) {
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            sThreadLocal.set(new Looper(quitAllowed));
        }复制代码

我们暂且不说这个**prepareMainLooper**有什么作用，从代码功能，我们可以看出来，程序做了两件事情：  
1、**sThreadLocal**实例set了一个Looper的实例。  
2、通过**sThreadLocal.get() != null**判断达到不允许该线程中重新申请一个looper实例。  
其中，**ThreadLocal**有点像HashMap的机制，key作为一个唯一标识值，且唯一对应一个value。所以这里为当前线程实例了一个独立标识的Looper实例。

再看Looper.loop()方法

public static void loop() {
            final Looper me = myLooper();
            if (me == null) {
                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
            }
            final MessageQueue queue = me.mQueue;
    
      //...
            for (;;) {
                Message msg = queue.next(); // might block
                if (msg == null) {
                    // No message indicates that the message queue is quitting.
                    return;
                }
    
                // This must be in a local variable, in case a UI event sets the logger
                Printer logging = me.mLogging;
                if (logging != null) {
                    logging.println(">>>>> Dispatching to " + msg.target + " " +
                            msg.callback + ": " + msg.what);
                }
    
                msg.target.dispatchMessage(msg);
    
                if (logging != null) {
                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
                }
    
                // Make sure that during the course of dispatching the
                // identity of the thread wasn't corrupted.
                final long newIdent = Binder.clearCallingIdentity();
                if (ident != newIdent) {
                    //...
                }
    
                msg.recycleUnchecked();
            }
        }
    
    ----------------------------------------------------------------------
    
    public static @Nullable Looper myLooper() {
            return sThreadLocal.get();
     }复制代码

在上面的方法loop中，最有亮点当然就是**for (;;)**死循环了！(不然怎么叫循环机制呢哈)。从程序代码中，我们可以发现looper机制，执行循环机制的开始入口，便是**loop**方法！但是，我们在执行之前，应该要知道是哪个线程的Looper实例执行了？这里有个关键方法**myLooper()**。看到方法体的**sThreadLocal.get()**后，读者会不会瞬间刚刚在哪里判断的时候也调用了。

对！就是Looper机制中的**prepare**方法，初始化了当前Looper的实例对象，最后通过调用**loop()**启动了循环机制！大概我写下顺序

* 一般线程 ：
     Looper.prepare() --> Looper.loop()
    
    * 主线程：
    Looper.prepareMainLooper(); ->Looper.prepare() && 初始化sMainLooper(也就是getMainLooper获取的主线程looper实例，这个动作是synchronized线程同步的) --> Looper.loop()复制代码

\#\#\#MessageQueue

**MessageQueue**是一个消息队列机制，遵循先进先出的规则，简单讲述这里由插入与删除两个动作，其中**enqueueMessag()**作为消息插入、**next()**则是取出数据的时候程序会将其取出的数据移除消息队列，其中next是一个阻塞试的死循环机制，只要有消息插入，将进行next取出。

这里MessageQueue不做更多的说明，首先看到Looper机制是如何关联MessageQueue列的，首先定位在Looper初始化实例的构造方法与loop启动机制的方法

private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed);
            mThread = Thread.currentThread();
        }复制代码

从代码结构中，可以发现消息队列MessageQueue，在构造方法中实例化。而且loop方法死循环执行中，是不断监测队列中next是否有消息来临，当然前面也说明了，next是阻塞的，因此等到有消息message插入的时候，才会通过next获取到message实例，然后在进行下一动作。

### Handler ###

前面的铺垫就是为了今天的主角，首先分析Handler之前，我们都知道日常我们的handler用法，例如如下：

private static Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (msg.what == 1000){
                    //..doing
                }
            }
        };
        handler.sendEmptyMessage(1000);复制代码

这里我们直接通过构造方法到send方法再到接收源码进行分析

首先锁定到构造方法

public Handler(Callback callback, boolean async) {
            if (FIND_POTENTIAL_LEAKS) {
                final Class<? extends Handler> klass = getClass();
                if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                        (klass.getModifiers() & Modifier.STATIC) == 0) {
                    Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                        klass.getCanonicalName());
                }
            }
    
            mLooper = Looper.myLooper();
            if (mLooper == null) {
                throw new RuntimeException(
                    "Can't create handler inside thread that has not called Looper.prepare()");
            }
            mQueue = mLooper.mQueue;
            mCallback = callback;
            mAsynchronous = async;
        }复制代码

锁定到重要的两句话**mLooper = Looper.myLooper();**和**mQueue = mLooper.mQueue;**。这里通过上面分析主线程的Looper机制，应该很熟悉了，构造器主要做的其中两个重要的事情：  
1、获得当前线程（一般主线程）Looper机制实例  
2、通过looper实例获得与Looper实例绑定关系的消息队列实例mQueue

其次我们再看下发送消息，这里我直接跳转到最终处理消息的逻辑：

sendEmptyMessage ->sendEmptyMessageDelayed ->sendMessageDelayed ->sendMessageAtTime->enqueueMessage复制代码

发送个消息也不容易啊~

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
            MessageQueue queue = mQueue;
            if (queue == null) {
                RuntimeException e = new RuntimeException(
                        this + " sendMessageAtTime() called with no mQueue");
                Log.w("Looper", e.getMessage(), e);
                return false;
            }
            return enqueueMessage(queue, msg, uptimeMillis);
        }复制代码

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            msg.target = this;
            if (mAsynchronous) {
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
        }复制代码

不知道读者注意到了没有，最终Handler发送Meesage的时候，其实最终还是调用了与当前线程的Looper实例所绑定的消息队列中的enqueueMessage，即只是一个插入message到消息队列的过渡者！当然，其中通过**msg.target = this;**，message对象绑定了调用目标是当前Handler对象。这里我建议读者可以手动自己看下源码，不难理解。

前面简述MessageQueue的时候有提及到，MessageQueue只有两个操作，即单链表的插入以及删除。由于next()是阻塞式的死循环，只要消息队列有消息，则马上将message取出并溢出。

最后联系到真正处理转发的Looper实例，前面也说loop方法死循环执行中，在不断监测队列中next是否有消息来临。如果Handler此时发送Message到消息队列中，则绑定关系中的Looper实例中的loop方法将会获得此时的message，经过消息队列终于来到当前线程的looper机制中，此时loop方法通过**msg.target.dispatchMessage(msg)**返回给Hander对象，这里我再贴下loop方法

public static void loop() {
               ...
            for (;;) {
                Message msg = queue.next(); // might block
                if (msg == null) {
    
                    return;
                }
    
               // 这里的target，前面我们可以在Handler看到每个Message都会通过target绑定发送Handler对象
              // 最终消息交给Handler中dispatchMessage方法处理
                msg.target.dispatchMessage(msg);
    
                msg.recycleUnchecked();
            }
        }复制代码

// 最终处理再转发给 handleCallback 或 handleMessage
    public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                handleMessage(msg);
            }
        }复制代码

上面笔者直接通过注释讲述了最后的处理。当然这里我们也可以观察下这里面的mCallback，这里是我们初始化Handler的时候有构造方法可以将mCallback进行初始化，这里我们可以观察到在执行Handler的handleMessage前还经过**mCallback.handleMessage(msg)**的判断，说明mCallback在这里起到一个拦截的作用，如果实例者回调返回true，就不会将消息回调给handleMessage。

笔者是花了三个多小时过了下源码和记录了分析的笔记，当别人提起底层的源码机制，这块真的有点薄弱。平常应用层开发多了，花在源码层分析的时间也少了，所以一有时间还是得多读读书，多读读代码，提升下思维和能力~共勉哈！最后我引用下别人的一张图做最后的总结，感谢阅读！

Android Handler.png

傻小孩b mark共勉，写给在成长路上奋斗的你

[b]: https://link.juejin.im?target=http%3A%2F%2Fgold.xitu.io%2Fuser%2F57e089588ac2470061715771