Android的消息机制和源码分析

消息机制概述

Android的消息机制主要是Handler的消息机制,Handler的运行需要底层的MessageQueue和Looper的支持。
Handler:负责将需要更新界面的子线程切换到主线程。
MessageQueue:消息队列,以队列的形式对外提供插入和删除的工作,其内部结构是以链表的形式存储消息的。
Looper:以无限循环的方式来查找是否有消息,如果有就处理消息,否则就一直等待着。
ThreadLocal:通过ThreadLocal可以在不同线程里互不干扰的存储和提供数据。

由于Android的UI控件是线性不安全的,所以不能再子线程中更新UI,checkThread()检测主线程更新UI,Handler用于解决从子线程切换到主线程更新UI。

void checkThread(){
    if(mThread != Thread.currentThread){
        throw new CalledFromWrongThreadException("Only the original thread that created a view hierarchy can touch its views.");
    }
}

Handler工作过程:

1、Handler的post()讲一个Runnable投递到Handler内部的Looper中去处理。
2、Handler的send()发送一条消息,这条消息会在looper中去处理。
当Handler的send()被调用时,它会调用MessageQueue的enqueueMessage()将消息放入消息队######列,当Looper发现有信息到来时就会处理这个消息,最终消息中的Runnable()或者Handler的######handleMessage()就会被调用。过程如下:

MessageQueue的工作原理

MessageQueue主要包含两个操作:插入和读取。读取本身会伴随着删除。插入和读取对应的方法是enqueueMessage和next,MessageQueue是一个用单链的数据结构来维护消息列表。下面是enqueueMessage()和next()的实现:

boolean enqueueMessage(Message msg, long when){
    synchronized(this){
        msg.markInUse();
        msg.when = when;
        Message p = mMessage;
        boolean needWake;
        if(p == null || when == 0 || when < p.when){
            msg.next = p;
            mMessage = msg;
            needWake = mBlocked;
        }else{
            needWake = mBlocked && p.target == && msg.isAsynchronous();
            Message prev;
            for(;;){
                prev = p;
                p = p.next;
                if(p == null || when < p.when){
                    break;
                }
                if(needWake && p.isAsychronous()){
                    needWake = false;
                }
            }
            
        }
        if(needWake){
            nativeWake(mPtr);
        }
    }
    return true;
}

Message next(){
    int pendingIdleHandlerCount = -1;
    int nextPollTimeOutMillis = 0;
    for(;;){
        if(nextPollTimeOutMillis != 0){
            Binder.flushPendingCommands();
        }
        nativePollOnce(ptr, nextPollTimeOutMillis);
        synchronized(this){
             ......
        }
    }
}
从enqueueMessage()和next()的实现来看,MessageQueue的队列主要是通过单链表的形式进行插入和移除数据。

Looper的工作原理

Looper会不停的从MessageQueue中查看是否有新消息,有就立刻处理,否则会一直阻塞在那里,它的构造方法中会创建一个MessageQueue,然后将当前线程对象保存起来。

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

Handler的工作需要Looper,没有Looper的线程就会报错,通过Looper.prepare()为当前线程创建一个Looper,然后通过Looper.loop()来开启消息循环。

new Thread("Thread #2"){
    public void run(){
        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();
    }
}

Looper也是可以退出的,Looper提供了quit()和quitSafely()来退出Looper,区别是:quit()直接退出一个Looper,quitSafely()设置一个退出标记,把消息队列中的已有消息处理完毕后才安全退出。如果退出Looper,则该线程终止,建议不需要的时候终止Looper。

Looper最重要的一个方法是loop(),只有调用了loop()后,消息循环系统才会真正的开始执行,下面是loop()源码:

public static final void loop() {
    Looper me = myLooper();  //得到当前线程Looper
    MessageQueue queue = me.mQueue;  //得到当前looper的MQ
    
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    // 开始循环
    while (true) {
        Message msg = queue.next(); // 取出message
        if (msg != null) {
            if (msg.target == null) {
                // message没有target为结束信号,退出循环
                return;
            }
            if (me.mLogging!= null) me.mLogging.println(
                    ">>>>> Dispatching to " + msg.target + " "
                    +msg.callback + ": " + msg.what
                    );
            // 将真正的处理工作交给message的target
            msg.target.dispatchMessage(msg);
            if (me.mLogging!= null) me.mLogging.println(
                    "<<<<< Finished to    " + msg.target + " " + msg.callback);
            
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf("Looper", "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        +Long.toHexString(newIdent) + " while dispatching to "
                        +msg.target.getClass().getName() + " "
                        +msg.callback + " what=" + msg.what);
            }
            // 回收message资源
            msg.recycle();
        }
    }
}

Looper的loop()是一个死循环,当MessageQueue的next()返回了null时,loop()跳出循环,或者调用Looper的quit().当Looper调用loop()时,Looper就是调用MessageQueue的quit()来通知消息队列退出,此时它的next()返回null。如果MessageQueue的next()返回新消息时,Looper就会处理这条消息:msg.dispatchMessage(msg),这里的msg.target是发送这条消息的Handler对象,这样Handler发送的消息最终又交给它的dispatchMessage()去处理了。但是这里不同的是,Handler的dispatchMessage()是在创建Handler时使用的Looper中执行的,这样就成功的将代码逻辑切换到指定的线程中去执行了。

Handler的工作原理

Handler的工作主要包括发送和接受消息。消息的发送通过post的一系列方法或者send的一系列方法实现。

 public final boolean post(Runnable r)
{
   // 注意getPostMessage(r)将runnable封装成message
   return  sendMessageDelayed(getPostMessage(r), 0);
}

private final Message getPostMessage(Runnable r) {
    Message m = Message.obtain();  //得到空的message
    m.callback = r;  //将runnable设为message的callback,
    return m;
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
    boolean sent = false;
    MessageQueue queue = mQueue;
    if (queue != null) {
        msg.target = this;  // message的target必须设为该handler!
        sent = queue.enqueueMessage(msg, uptimeMillis);
    }
    else {
        RuntimeException e = new RuntimeException(
            this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
    }
    return sent;
}

Handler发送消息的过程就是向消息队列中插入一条消息,MessageQueue的next()就会返回这条消息给Looper,Looper收到消息后就开始处理了,最终消息有Looper交给Handler处理,即Handler的dispatchMessage()会被调用:

 public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        // 如果message设置了callback,即runnable消息,处理callback!
        handleCallback(msg);
    } else {
        // 如果handler本身设置了callback,则执行callback
        if (mCallback != null) {
             /* 这种方法允许让activity等来实现Handler.Callback接口,避免了自己编写handler重写handleMessage方法
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 如果message没有callback,则调用handler的钩子方法handleMessage
        handleMessage(msg);
    }
}

// 处理runnable消息
private final void handleCallback(Message message) {
    message.callback.run();  //直接调用run方法!
}
// 由子类实现的钩子方法
public void handleMessage(Message msg) {

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

Handler处理消息的过程如下:
首先检查Message的callback是否为null,不为null 就通过handleCallBack来处理消息,Message的callback是一个Runnable对象,实际上就是Handler的post()所传递的Runnable参数。
其次检查mCallback是否为null,不为null就调用handleMessage()来处理消息。Callback是个接口.
最后调用Handler的handleMessage()来处理消息。

你可能感兴趣的:(Android的消息机制和源码分析)