Android消息机制

引言

从开发的角度说，Handler是Android消息机制的上层接口，使得在开发的过程中只需要和Handler交互即可。
　　Handler的使用过程很简单，通过它可以将一个任务切换到Handler所在的线程中进行.Handler一般被用于更新UI。因为Android不允许在子线程中更新UI，所以子线程需要通过Handler发送信息到主线程更新UI。
　　Handler不仅可以用于在其他的线程处理的过程中更新UI，还可以处理其他的一些线程间的通信。

概述

简介

Android的消息机制实际上指的是Handler的消息机制，而Handler的运行需要通过底层的MessageQueue和Looper的支撑。MessageQueue即消息队列，实际上由单链表而不是队列储存消息列表。Looper即循环，也可以被理解为消息循环，它不能去处理消息，而Looper就填补了这个功能，Looper通过运行一个死循环，从MessageQueue中获取信息，如果有则处理信息，否则就一直阻塞等待。Looper中还有一个特殊的概念，ThreadLocal，ThreadLocal用于在每个线程中储存数据。Handler创建的时候会默认使用当前线程的Looper对象来构造消息循环系统，而Android通过ThreadLocal可以在不同的线程中互不干扰的获取数据的特点，通过ThreadLocal轻松地获取每个线程的Looper。
　　需要注意的是，线程默认是没有Looper的，如果需要使用Handler则必须为线程创建Looper。而Android中的UI线程，即ActivityThread，在被创建的时候会初始化Looper，所以不需要再创建Looper就可以使用Handler。

使用Handler的原因

Android的消息机制中，Handler和MessageQueue、Looper实际上是一个整体，而在开发的过程中，开发者只是比较多的接触Handler而已。而Handler的主要作用是将一个任务切换到它Handler所在的线程执行，Android提供这样的一个功能是它规定UI访问只能在主线程中执行，如果在子线程中访问UI，那么程序就会抛出异常，究其原因，是因为ViewRootImpl通过checkThread方法对UI操作做了验证。
　　因为Android的这个限制，所以必须在主线程中访问UI，但是Android又不建议在主线程中进行耗时的操作，否则会导致程序出现ANR。假如我们需要进行耗时工作，如从网络中获取数据并更新UI，这个时候必须新建一个子线程来完成网络请求操作，获取完毕后需要在子线程中更新UI，但子线程中无法直接更新UI，所以这个时候必须通过Handler来将UI的工作切换到主线程中，解决了子线程中无法访问UI的矛盾。这就是为什么Android提供Handler。

不允许在子线程中更新UI的原因

Android系统不允许在子线程中更新UI的原因是，Android中的UI并不是线程安全的，而如果在多线程中并发访问可能会导致UI控件处于不可预期的状态。Android系统也不对UI控件的访问提供锁机制，原因有二，首先添加锁机制会让UI访问的逻辑变得复杂，其次锁机制会因为其会阻塞某些线程的执行而降低UI访问的效率。而鉴于这两个问题，最简单高效的方法就是通过单线程模型来处理UI操作，对开发者来说不不至于太复杂，只需通过Handler来切换UI访问的线程即可。

Looper的构造

Handler创建的时候会采用当前线程的Looper来构造内部的消息循环系统，如果当前的线程没有Looper，那么就会抛出RuntimeException异常。
　　解决这个问题只需要为当前的线程创建Looper即可，或者在一个有Looper的线程中创建Handler。
　　而当Handler创建完毕后，这个时候其内部的Looper以及MessageQueue就可以和Handler一起协同工作了，然后通过Handler的post方法将一个Runnbale投递到Handler内部的Looper进行处理，而其实post方法的内部也是通过send方法完成的。
　　以下是send方法的工作流程。
　　当Handler的send方法被调用时，它会调用MessageQueue的enqueueMessage方法将这个消息放入队列中，然后Looper发现有新消息到来时，就会处理这个消息。最终消息中的Runnable或者Handler的方法就会被调用。注意Handler默认创建的Looper是运行在创建Handler的线程中的，这样一来Handler中的业务逻辑就被切换到所在的线程中处理了。
　　下图是Handler的工作过程图。
　　

Handler的工作过程

Android的消息机制分析

ThreadLocal

ThreadLocal是一个线程内部的数据储存类，通过它可以在线程的内部存储信息。并在指定的线程中可以获取到储存的数据，对于其他线程来说则无法获取到。
　　对于Hanlder来说，它需要获取当前线程的Looper对象，很显然Looper的作用域就是线程并且不同的线程具有不同的Looper，这个时候通过ThreadLocal就可以轻松地实现Looper在线程中的获取。

消息队列的工作原理

消息队列即Android中的MessageQueue，MessageQueue主要包含两个操作，插入和读取，而读取操作本身会伴随着删除操作，插入和独缺对应的方法分别为enqueueMessage和next，其中enqueueMessage的作用是往消息队列里面插入一条信息，而next的作用是从消息队列中插入一条信息，而next的作用是从消息队列中取出一条信息并且将其从消息队列中移除。而MessageQueue的内部实现是通过一个单链表的数据结构来维护消息列表，单链表在插入和删除上复杂度为O(1)。
　　enqueueMessage的内部实现实际上就是单链表的插入操作，将Message插入到队列中去，其优先级和delay字段有关。
　　next的内部实现包含着一个无限循环的方法，如果内部的消息队列中没有信息或者存在信息但是还在delay中，那么将一直阻塞，而当有新消息到来时，next将返回这条信息，并从单链表中移除。

Looper的工作原理

Looper在Android的消息机制中扮演着消息循环的角色，具体来说就是它不停地从MessageQueue中查看是否有新消息，如果有新消息则立刻进行处理，说否则就一直阻塞。Looper的构造方法如下，在构造方法中它会创建一个MeesageQueue消息队列，然后将当前线程的对象保存起来。

private Looper(boolean quitAllowed) {
    mQueue = new MesssageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

而Handler的工作需要Looper，在没有Looper的线程创建Handler就会抛出异常，而为一个没有Looper的线程创建Looper只需要通过调用Looper.prepare()即可，接着通过Looper.loop()开启消息循环，代码如下。

new Thread("Thread#2") {

    @Override
    public void run() {
        Looper.prepare();
        Hanlder handler = new Handler() {
            // some code
        }
        Looper.loop():
    }
}

Looper除了prepare方法外，还提供了prepareMainLooper方法，这个方法主要是给主线程也就是ActivityThread创建Looper使用的，其本质也是通过prepare方法来实现的。由于主线程的Looper方法比较特殊，所以Looper提供了一个getMainLooper方法，通过它可以在任何地方获取到主线程的Looper。
　　Looper也是可以退出的，Looper提供了quit和quitSafely来退出一个Looper，两者的在于，quit会直接退出Looper，而quitSafely只是设定一个退出标记，然后把消息队列的已有印象处理完毕才完全地退出。Looper退出后，通过Handler发送的消息会失败，这个时候Handler的send方法会返回false。
　　在子线程中，如果手动为其创建了Looper，那么在所有事情都完成以后应该调用quit来终止消息循环，否则这个子线程则一直处于等待的状态。而当子线程推出Looper后，这个线程会立刻停止，因此建议当子线程不需要再运行的时候终止Looper。

Loop.loop()

Looper最重要的是loop方法，只有调用了loop方法，消息循环系统才真正的开始。 Looper的loop方法的工作过程也比较好理解，loop是一个死循环，唯一跳出循环的方式是MessageQueue的next方法返回了null。而当Loooper的quit方法被调用时，Looper就会调用MessageQueue的quit或者quitSafely通知消息队列退出，当消息队列被标记为退出状态时，它的next方法就会返回null。也就是说，Looper必须退出，否则Looper方法将无限循环下去，loop方法会MessageQueue的next方法来获取新消息，而next是一个阻塞的操作，当没有消息的时候，next方法会一直阻塞，这同时也导致loop方法一直阻塞。如果MessageQueue的next方法返回了新消息，Looper就会处理这条消息"msg.target.dispatchmessage(msg)，这里的msg.target是发送这条消息的Handler对象，这样handler发送的消息最终又交给了它的dispatchMessage方法处理。但是这里不同的是，Handler的dispatchMessage方法是在创建Hanlder所使用的Looper中执行的，这就成功地将代码逻辑切换到指定的线程中执行了。

Handler的工作原理

Handler的工作主要包含信息的发送和接收过程。消息的发送可以通过post的一系列方法以及send的一系列方法来实现，post的一系列方法最终是通过send的一系列方法来实现的。
　　Handler内部源码中发送消息的过程仅仅是向消息队列里面插入了一条信息，MessageQueue的next方法就会返回这条消息给Looper，Looper收到消息后就开始处理了，最终消息由Looper交由Handler处理，即Handler的dispatchMessage方法会被调用，这时Handler就进入了处理消息的阶段。

Handler处理消息的过程

首先，先检查Message的callback是否为null，不为null则通过handleCallback来处理消息。Message的callback是一个Runnable对象，实际上就是通过Handler的post方法所传递的Runnable参数。handleCallback的逻辑也是很简单的，代码如下

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

privare static void handlerCallback(Message msg) {
    msg.callback.run();
}

其次，检查mCallback是否为null，不为null就调用mCallback的handlerMessage方法来处理消息。Callback是个接口，代码定义如下。

public interface Callback {
        public boolean handleMessage(Message msg);
    }

而通过Callback可以采用如下方式创建Handler对象：Handler handler = new Hanler(callback)。使用Callback的意义在于不用创建一个Hanlder的实例而不用派生Handler的子类，并且可以在Callback的handleMessage通过返回false时，通过Handler的handleMessage方法来处理。
　　日常开发中，也可以通过派生Handler子类的方式并重写handleMessage方法来处理具体的消息，而Callback通过另一种方式也可以实现。
　　而最后，通过调用Handler的handlerMessage方法来处理消息。
　　Handler处理消息的过程如图下。
　　

Handler处理消息流程图

指定Looper

Handler还有一个特殊的构造方法，可以指定一个Looper来构造Handler，代码如下。

public Hanlder(Looper looper) {
    this(looper. null, false)
}

而Handler的默认构造方法是public Handler()，这个构造方法会调用以下代码的构造方法。

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

可以看出假如当前线程没有Looper的话，就会抛出异常。

主线程的消息循环

Android的主线程就是Activity，主线程的入口方法是main，在main方法中系统会通过Looper.prepareMainLooper()来创建主线程的Looper以及MessageQueue，并通过Looper.loop()来开启消息循环。
　　主线程的消息循环开始了以后，AcitivyThread还需要一个Handler来和消息队列进行交互，这个Hanlder就是ActivityThread.H，它内部定义了一组消息类型，主要包含四大组件的启动和停止等过程。
　　AcitivityThread通过ApplicationThread和AMS进行进程间通信，AMS以进程间通信方式完成AcitivityThread的请求后回调ApplicationThread中的Binder方法，然后ApplicationThrad会向H发送消息，H收到消息后会将ApplicationThread中的逻辑切换到ActivityThread中执行，即切换到主线程中去执行，这个过程就是主线程的消息循环过程。