Android系统Handler消息处理机制(二)

引言

在Android系统Handler消息处理机制(一)这篇文章中说道,Activity中Looper是在ActivityThread中创建的主线程,当创建一个Handler的时候就得到当前线程的Looper对象,并得到mQueue队列.

思考?

我们既然在Handler中得到属于当前主线程的Looper了,并且得到属于当前线程的mQueue队列了,那么我们用这个消息队列做什么?如何才能给消息队列中发消息,这个消息队列又是在哪里创建的呢?

带着上述问题我们看看源码怎么说!

首先看Handler的sendMessage方法

//Handler.java通过handler.sendEmptyMessage(1);
 public final boolean sendEmptyMessage(int what)
{
    return sendEmptyMessageDelayed(what, 0);//继续向下追
}
  public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);//继续向下追
}
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;//mQueue是什么时候有值的呢?
    if (queue == null) {
        RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");
    ...
        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的发送消息源代码,最后发现调用的是MessageQueue queue的enqueueMessage方法将消息传递
这个时候我们注意几个问题:
1.msg类型是Message implements Parcelable {类型,说明可以跨进程
2.msg.target = this;//这里的msg.target就是当前Handler类
3.MessageQueue queue = mQueue;是在sendMessageAtTime方法中被赋值,问题是mQueue在什么时候被赋值呢?(看上节)

   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) {
        ...
            }
        }
        mLooper = Looper.myLooper();
        ...
        mQueue = mLooper.mQueue;
        ...
    }

所以在Handler的构造中mQueue被赋值,mLooper是主线程的Looper,主线程是在ActivityThread中创建的,当执行ActivityThread的main()方法的时候执行了Looper.prepareMainLooper();

public static void prepareMainLooper() {
    prepare(false);//向下追
  ...
}
private static void prepare(boolean quitAllowed) {
    ...
    sThreadLocal.set(new Looper(quitAllowed));//继续追Looper的构造
}
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);//创建消息队列
    mThread = Thread.currentThread();
}

小结

Handler的构造得到属于当前线程的Looper,此Looper是主线程的Looper,主线程在ActivityThread中创建,在创建的时候调用Looper的构造方法,构造方法中创建了MessageQueue对象.

那么既然我们现在知道Handler.sendEmptyMessage()-->queue.enqueueMessage()其中queue是mQueue在ActivityThread调用prepareMainLooper的时候创建.那么我们具体看看queue.enqueueMessage()这个方法做了什么事情.

MessageQueue.java

boolean enqueueMessage(Message msg, long when){
...
    synchronized (this) {
       ...
        msg.when = when;
        Message p = mMessages;//p指向消息队列的头部
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;//没有消息,就将msg作为头部
            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; 
            prev.next = msg;
        }
        if (needWake) {//需要唤醒,则唤醒线程
            nativeWake(mPtr);
        }
    }
    return true;
}

可以看出来这里面做的是链表的增删,将msg进行插入.队列为空的时候将msg作为头部.

所以有如下小结:
通过Handler发送消息,是就上就是把msg插入到MessageQueue队列中,进行判断看插入时候是不是需要唤醒线程.

引申问题!

既然知道了插入队列,不读取,插入也没有意义呀,那么在哪里读取呢?

我们通过上节知道,在loop()方法中有句代码Message msg = queue.next();,所以我们知道了是在Looper.loop()方法中调用queue.next()方法,但是我们并不知道next()怎么一个运作机理,现在我们就从MessageQueue的构造方法开始,分析一下MessageQueue如何拿出消息.

MessageQueue(boolean quitAllowed) {
        mQuitAllowed = quitAllowed;
        mPtr = nativeInit();//好奇的宝宝怎么可能不追下去
    }
    //这里分享一个知识点,就是native开头的方法都是本地方法,本地方法命名规则是报名+类名字+方法名并且将所有.号替换成_

static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();//创建native层的NativeMessageQueue我们继续追下去
    ...
    nativeMessageQueue->incStrong(env);
    return reinterpret_cast<jlong>(nativeMessageQueue);
}

NativeMessageQueue::NativeMessageQueue() :mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);//创建一个Looper对象
        Looper::setForThread(mLooper);
    }
}

这里得解释一下,要不然后面看着懵逼,为什么多了一个Looper对象,还怎么才native层,不是在java层吗?怎么跑的?
这里就要解释一下了,这个Looper和java层那个Looper并没有直接关系,netive的Looper也是实现了一套完整的消息机制,那么究竟这个Looper干了啥,我们继续追到Looper中.

Looper::Looper(bool allowNonCallbacks) :... {
    mWakeEventFd = eventfd(0, EFD_NONBLOCK);//功能进程(线程)间的等待/通知(wait/notify) 机制.设置非阻塞
    ...
    AutoMutex _l(mLock);
    rebuildEpollLocked();//暂时没发现啥,继续看下去
}

这里要介绍一下eventfd函数,这个是Linux内核新增加的函数,实现了线程之间事件通知的方式
函数返回一个文件描述符，与打开的其他文件一样，可以进行读写操.
eventfd也可以放到监听队列中返回的fd可以进行如下操作：read、write、select(poll、epoll)、close.
eventfd的缓冲区大小是sizeof(uint64_t)也就是8字节，它是一个64位的计数器，写入递增计数器，读取将得到计数器的值，并且清零。

void Looper::rebuildEpollLocked() {
    ...
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    ...
    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event)); 
    eventItem.events = EPOLLIN;
    eventItem.data.fd = mWakeEventFd;//记录需要监听的fd就是上面mWakeEventFd = eventfd(0, EFD_NONBLOCK);
    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);//注册事件
    for (size_t i = 0; i < mRequests.size(); i++) {
        const Request& request = mRequests.valueAt(i);
        struct epoll_event eventItem;
        request.initEventItem(&eventItem);
        int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, request.fd, & eventItem);
        ...
    }
}

小结上面这一丢丢:
也就是说,在MessageQueue构造中创建了native层的NativeMessageQueue,NativeMessageQueue创建导致了native层的Looper创建,底层的Looper创建进行操作就是利用内核函数eventfd实现一个8字节的缓冲区并且用epoll_ctl进行监听文件句柄

---

那么上面我们看完了MessageQueue的创建过程,但是我们还不知道创建了辣么多机制东东在哪里用咋整,下一步我们就开始分析MessageQueue拿数据的过程.

由于第一节我们已经说道,在Java层的Looper.loop()方法中是个死循环,死循环中调用MessageQueue中的next()方法.那么我们就看看MessageQueue中的next方法

   Message next() {
        ...
        for (;;) {
           ...
           nativePollOnce(ptr, nextPollTimeoutMillis);//注意这个本地方法,ptr是NativeMessageQueue地址
            synchronized (this) {
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;//指向消息头
                ...
                if (msg != null) {//找到第一条消息
                    if (now < msg.when) {//消息没有到达时间,计算出要需要多少时间能到达这个消息
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        mBlocked = false;//取消阻塞
                        //下面是断开链表一个节点
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        return msg;返回消息
                    }
                } else {
                    nextPollTimeoutMillis = -1;
                }
                if (mQuitting) {//当在quit函数中设置mQuitting=true,表明退出,则执行下面
                    dispose();//销毁native对象
                    return null;
                }
               ...
            }
           ...
        }
    }

上面我们看到了将消息从头部开始一条一条拿出,并且如果消息不为空,那就返回msg,当退出的时候调用dispose()销毁native中的对象.

我们好奇了,那nativie中刚才的代码一会eventfd的一会epoll_ctl的,在next方法中没体现到他们的用处呀.稍安勿躁,看见next方法中还有一个nativePollOnce函数没有介绍吗?下面就来分析这个函数究竟做了什么事情.

static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(env, obj, timeoutMillis);//继续追
}

void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
    mPollEnv = env;
    mPollObj = pollObj;
    mLooper->pollOnce(timeoutMillis);//调用了native层mLooper的pollOnce方法.继续追
    mPollObj = NULL;
    mPollEnv = NULL;
    if (mExceptionObj) {
        env->Throw(mExceptionObj);
        env->DeleteLocalRef(mExceptionObj);
        mExceptionObj = NULL;
    }
}

  inline int pollOnce(int timeoutMillis) {
        return pollOnce(timeoutMillis, NULL, NULL, NULL);//继续追
    }

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) {
        ...
        result = pollInner(timeoutMillis);//继续追
    }
}

int Looper::pollInner(int timeoutMillis){
    ...
    //mEpollFd就是我们前面epoll_ctl注册的mEpollFd
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    ...
    return result;
}

小结:
我们从MessageQueue的next()方法入手,一步步最后追寻到native层的 Looper::pollInner方法的调用,也就是说,我们在next方法内部大部分时间都是在这里阻塞,但是此时阻塞并不消耗cpu资源,所以如果向eventfd写入数据,epoll_wait就会返回,阻塞结束,就可以在java层拿数据了.

大结:
这个时候我们已经分析的很清楚了,那个线程那个进程做了什么事情,如果还不了解,在继续多读几遍,相信读者一定会有不一样的感受.最后我们在大概说说流程.

在ActivityThread.main()方法被调用的时候就创建了主线程,主线程是什么,主线程是一个消息队列+不断循环处理消息.
Handler的创建,创建了java层的Looper对象,Looper创建了MessageQueue对象,MessageQueue创建了native层的NativeMessageQueue对象,NativeMessageQueue对象创建了native的Looper对象,和使用epoll机制监听eventfd返回的句柄(进行线程通信),然后就是循环,java层的loop中调用MessageQueue的next()方法,next()方法中做了两件大事情,一个是调用到native中进行阻塞,一个是从头开始读取消息队列中的msg进行分离返回.
当我们使用Handler中的sendXXX方法发送消息的时候,最终调用的是MessageQueue queue.enqueueMessage()方法将一个msg插入到消息队列中.