美文网首页
Android消息机制

Android消息机制

作者: 呆呆李宇杰 | 来源:发表于2017-06-20 20:52 被阅读40次

    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中执行,即切换到主线程中去执行,这个过程就是主线程的消息循环过程。

    相关文章

      网友评论

          本文标题:Android消息机制

          本文链接:https://www.haomeiwen.com/subject/zlhnqxtx.html