Android消息机制的源码理解

在Android应用程序中,存在一个主线程我们通常叫做UI线程,可以进行界面的更新等,进行系统的消息发送。接触Android久了,就会知道，Activity的生命周期就是通过系统内部的Handler发送消息来进行回调,其中消息传递过程是Handler的消息机制；

为什么要使用Handler的消息机制？
—它的设计避免了多线程的并发执行操作，我们知道Android规定：UI只是支持单线程模型。
假如多个线程都更新UI的界面，就会发生线程不安全问题，造成数据的丢失等等；
有了Handler之后一些好事的的操作都可以放到其他子线程里面执行，执行完毕之后可通过Handler与UI主线程进行交互，这个过程很好的避免的多线程的操作，同时增强了用户的体验。

下图是消息机制总体流程图：

它主要涉及下面四个类 Handler、MessageQueue、Message、Looper；
Message:消息
MessageQueue:消息队列，负责存储消息，它内部其实是一个单链表的结构
Handler:负责消息的发送和处理.必须要关联当前线程中唯一的Looper对象，才可以，否则抛异常
Looper:负责消息队列中消息的轮询操作，每一个线程只能有唯一的Looper对象(比如UI线程)
在UI线程被创建的时候，就会初始化一个Looper对象(是唯一的)，然后在通过Looper.looper()方法(这个方法是一个无限循环方法)，发现MessageQueue中有消息的时候，就会把它取出发送给Handler的handleMessage()方法处理；
对于消息队列,当有消息的时候,它会被唤醒,来处理消息,当没有消息的时候,他就会处于阻塞状态。
消息基本传递过程大体是这样的:
1.Handler发送一个Message(消息)同时这个消息会插入MessageQueue(消息队列)中;
2.然后Looper会轮询这个消息队列，发现有消息,会取出这个消息;
3.取出来之后会把它传递给原来的Handler对象处理。

通过上面我们会有一个整体认识，下面通过源代码来进行剖析：
最开始UI主线程被创建的时候，在ActivityThread内部会创建一个唯一的Looper对象：

   public static void main(String[] args) {          //代码省略...        Process.setArgV0("<pre-initialized>");        Looper.prepareMainLooper();//创建消息循环Looper        ActivityThread thread = new ActivityThread();        thread.attach(false);        if (sMainThreadHandler == null) {            sMainThreadHandler = thread.getHandler();        }        AsyncTask.init();          //代码省略...        Looper.loop();//执行循环消息        throw new RuntimeException("Main thread loop unexpectedly exited");    }

上面有注释的两块地方,开始了对Looper的操作处理—
第一个方法Looper.prepareMainLooper()是初始化一个Looper对象和一个消息队列
第二个方法Looper.loop()是Looper对象对消息队列进行轮询操作,发现里面有消息的时候就会发给Handler处理，没有消息的时候就Looper对象本身就会处于阻塞状态
再接着看一下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();        }    }      public static void prepare() {        prepare(true);    }    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));    }

从这里我们可以看到，这个方法内部首先调用了prepare(false),
prepare(false)内部它先调用了ThreadLocal的get()方法，来进行判断当前UI线程中是否有Looper对象变量值，如果有的话，get方法返回就不等于null,那么这里就会抛一个异常“only one Looper may be created per thread ”意思就是每个线程只允许创建一个Looper对象，如果Looper对象已经有了那么就不能再调用这个方法了，否则会抛上面异常。这里因为是第一次启动创建，所以一定是null,不会报异常。
再往下面执行的时候调用 sThreadLocal.set(new Looper(quitAllowed));
ThreadLocal会把新new 的Looper对象设置进去，下次调用sThreadLocal.get()的时候可以取出的取出这个变量的值，当然前提是在同一个线程中(这里是UI线程)。熟悉线程的朋友，知道这个ThreadLocal类作用就是存储与当前线程有关的变量，不涉及其他线程！
执行到最后的时候，会调用Looper.myLooper()将looper对象赋值给到Looper类里面的sMainLooper变量。

 public static  Looper myLooper() {        return sThreadLocal.get();//再当前线程中通过ThreadLocal取出我们设置的Looper对象    }

通过new Looper(quitAllowed)我们看一下Looper的带参构造方法，就会发现原来消息队列MessageQueue被Looper内部创建了.

 private Looper(boolean quitAllowed) {        mQueue = new MessageQueue(quitAllowed);//Looper封装了消息队列        mThread = Thread.currentThread();    }

到这里,我们就会发现Android的UI线程中会有一个默认的Looper对象(而且是唯一的)，它里面还封装了一个消息队列。这样Looper和MessageQueue就关联上了
还有一个Looper.loop()方法,我们到后面提到再说…

下面我们在看看Handler是如何与Looper和MessageQueue关联上的呢？
当我们在UI主线程中创建一个Handler对象的时候(比如在一个Actvity中创建 Handler mHandler=new Handler();)其实在这个过程中会把主线程里面的Looper和MessageQueue分别赋值给到Handler里面的对应变量,这个看一下 Handler的构造方发就会发现

 public Handler() {        this(null, false);    } public Handler(Callback callback, boolean async) {          //省略次要代码...        mLooper = Looper.myLooper();//这里赋值Looper        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;//这里赋值MessageQueue        mCallback = callback;        mAsynchronous = async;    }

1,mLooper = Looper.myLooper();//这里赋值Looper,当前是在UI主线程里面，会把当前线程中唯一的一个Looper传递过来(上面已经分析了)；
同理mQueue = mLooper.mQueue;//这里赋值MessageQueue，也会把与Looper关联的唯一MessageQueue传递进来；
到这里也就是说我们创建的Handler对象里面包含了主线程的Looper和MessageQueue,这样Handler就和它们关联上了；

当使用Handler对象发送消息的时候会调sendMessage();

 public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    } public final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }  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);    }

发送消息的方法内部调用了发送延迟消息的方法，从内部知道是从开机到现在时间的上延迟了0秒，接着把这个时间当做是消息发送时间，接着调定时发送消息的方法，这个方法里面会先拿出消息队列，后面又会把这条消息插入消息队列里面。这一点从以上代码看还是比较容易理解的。接着上面代码往下继续看代码enqueueMessage(queue, msg, uptimeMillis)…

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;//这个this不就是当前的Handler        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }

msg.target = this，把Handler对象赋给了Message中的target引用，这样这条消息中的target指向Handler.
而queue.enqueueMessage(msg, uptimeMillis)就是消息队列自己插入消息的方法了。
这条条消息Message里面的target(Handler类型)引用指向了我们最开始创建的Hanlder对象
看看消息队列MessageQueue的queue.enqueueMessage(msg, uptimeMillis)是如何插入消息的：

 boolean enqueueMessage(Message msg, long when) {         //省略次要代码...        synchronized (this) {            msg.markInUse();            msg.when = when;            Message p = mMessages;            boolean needWake;            if (p == null || when == 0 || when < p.when) {                // New head, wake up the event queue if blocked.                msg.next = p;                mMessages = msg;                needWake = mBlocked;            } else {                needWake = mBlocked && p.target == null &&msg.isAsynchronous();                Message prev;                for (;;) {                    prev = p;                    p = p.next;                    if (p == null || when < p.when) {                        break;                    }                    if (needWake && p.isAsynchronous()) {                        needWake = false;                    }                }                msg.next = p; // invariant: p == prev.next                prev.next = msg;            }            // We can assume mPtr != 0 because mQuitting is false.            if (needWake) {                nativeWake(mPtr);            }        }        return true;    }

代码比较长，其实也没有什么，就不全部贴出来了，只看重要的部分，用心看，你会明白，MessageQueue内部存储其实使用的单链表存储结构，它并不是一个什么队列容器，（而是一个消息内部包含另一个消息的应用，通过这个应用可以查找到下一个消息），通过这个方法可以将一个消息插入到消息的队尾里去，这样一条Message消息就成功插入到里面去了。

好了，前面的过程我们都了解的差不多了，我来看看最重要的一个方法 Looper.loop()，
上面已经说了，一旦消息队列俩面有消息，Looper就会轮询出来发送给Handler处理。

    public static void loop() {        final Looper me = myLooper();//拿到当前UI线程中唯一的Looper对象        if (me == null) {            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        final MessageQueue queue = me.mQueue;//拿到当前UI线程中唯一MesssageQueue对象       //省略次要代码...        for (;;) {//看到了吗是一个无限循环        //阻塞的方法，没有消息的时候，MessageQueue会阻塞在这里            Message msg = queue.next(); //might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }              //省略次要代码...            msg.target.dispatchMessage(msg);//这条msg.target指向我们创建的Handler             //省略次要代码..            msg.recycle();        }    }

在这个方法里面先是取得前线程中的Looper对象，然后拿到消息队列，之后进入到for循环，这个for循环是一个死循环，第一行代码是注释可以知道，会阻塞，其实是一旦没有消息的时候就会休眠阻塞，一旦消息来了就会唤醒处理，这个next()方法里面也是消息队列链表的取出和删除操作，大家可以自己去读原码。这里取出刚才那条Message之后会调用 msg.target.dispatchMessage(msg)方法，msg.target指向的是放送这条消息的 Hanlder对象！呵呵，继续往下看看Handler类里面这个代码吧

 public void dispatchMessage(Message msg) {        if (msg.callback != null) {//判断Message自身Callback接口是否为null            handleCallback(msg);        } else {//到了Handler来处理消息了            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }

别的不说了，就看看handleMessage(msg),这个是Handler的接口回调方法。我们最熟悉的吧。

最后总结一下：
Handler负责消息的放送和处理，Looper负责轮询消息队列中的消息。消息队列负责消息的插入和取出删除。

更多相关文章

随机推荐