ActivityThread源码解析之Handler机制

最新推荐文章于 2024-05-04 09:13:02 发布

跨平台coder

最新推荐文章于 2024-05-04 09:13:02 发布

阅读量748

点赞数

分类专栏： Framework 文章标签： Handler Message MessageQueue Looper

本文链接：https://blog.csdn.net/woohyman/article/details/85810238

版权

Framework 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

本文分析了Hander几个重要类以及他们之间的关系。Handler是Android SDK来处理异步消息的核心类。
子线程与主线程通过Handler来进行通信。同时在应用的整个生命周期里也起着至关重要的作用。

源码分析

ActivityThread中也使用到了Looper循环，那么看下它里面是怎么使用。

先看下ActivityThread的main函数里面：

public static void main(String[] args) {
    Looper.prepareMainLooper();
	...
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    ...
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
	...
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

首先是调用prepareMainLooper做一些初始化的操作，接下来就是调用Looper.loop()来启动死循环处理消息。

在看下thread.attach(false)。他的作用就是将ApplicationThread对象与AMS关联起来，然后通过Handler通知主线程执行对应操作。

这个Handler是ActivityThread里面定义的，贴上部分代码：

private class H extends Handler {
    public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
        switch (msg.what) {
                ...
            case CREATE_SERVICE:
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.valueOf(msg.obj)));
                handleCreateService((CreateServiceData)msg.obj);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                break;
            case BIND_SERVICE:
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
                handleBindService((BindServiceData)msg.obj);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                break;
            case UNBIND_SERVICE:
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceUnbind");
                handleUnbindService((BindServiceData)msg.obj);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                break;
        }
    }

常用生命周期正是在这个Hander里面执行的，可见这个Looper承载着整个应用生命。

OK！大概说明下Handler的处理机制：handler发送Message给MessageQueue，Looper不断的遍历消息然后通知Handler处理。如下图所示：

0、

1、初始化

Looper的初始化有两种。prepareMainLooper()和prepare()。在子线程定义Handler的时候需调用prepare()方法，而UI线程已经定义了一个prepareMainLooper所以无需再执行。

先看看prepare()方法：

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

参数quitAllowed顾名思义就是true的时候允许quit操作。

看下sThreadLocal.set方法，他的作用就是将新建的Looper对象和当前线程绑定起来。

接着看下new Looper构造方法：

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

没什么内容，主要就是新建一个MessageQueue存入mQueue。接下来看下MessageQueue构造方法：

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

也没什么主要是将参数quitAllowed赋值给mQuitAllowed。

总的来说就是New出一个Looper和当前的线程绑定还有new处一个MessageQueue赋值给mQueue。

下面看下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();
    }
}

其实也就是比prepare()方法多了sMainLooper = myLooper()操作，就是将主线程的Looper赋值给sMainLooper 。还有就是prepare的参数为false即不允许quit。

2、启动Looper循环处理消息Looper.loop()

public static void loop() {
    final Looper me = myLooper();//标注1
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;//标注2

    for (;;) {
        // might block
        Message msg = queue.next(); //标注3
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
		...
        try {
            msg.target.dispatchMessage(msg);//标注4
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
		...
        msg.recycleUnchecked();//标注5
    }
}

标注1处先取出当前线程绑定的Looper，标注2处取出该Looper的mQueue也就是prepare的时候新建的mQueue。

获得当前线程对应的MessageQueue之后，接下来用了一个死循环操作Message对象。

标注3处是遍历queue链表的元素。

标注4是执行Message元素的dispatchMessage方法，贴上代码：

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

注意这边的msg.target是Message对象绑定的Handler对象，稍后会介绍。这边的msg.callback为NULL，那么就会调用handleMessage(msg)方法也就是调用Handle创建的时候handleMessage实现。

标注5回收该Message元素。

也就是说该死循环内先从MessageQueue取出Message对象，执行dispatchMessage方法，然后回收Message对象。

重点看下queue.next()方法是如何操作的，看下源码：

Message next() {
    // Return here if the message loop has already quit and been disposed.
    // This can happen if the application tries to restart a looper after quit
    // which is not supported.
    final long ptr = mPtr;
    if (ptr == 0) {//标注1
        return null;
    }
    for (;;) {
		...
        nativePollOnce(ptr, nextPollTimeoutMillis);//标注2

        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;//标注7
            ...
            if (msg != null) {
                if (now < msg.when) {//标注3
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    mBlocked = false;//标注4
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;//标注5
                    }
                    msg.next = null;
                    ...
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {//标注2
                dispose();
                return null;
            }
        }
    }
}

首先是返回null也就是退出Looper的两个位置：1、标注1处ptr == 0的时候，百度上看到消息队列被释放的时候，由于涉及到native后续再看。2、mQuitting标志为true，mQuitting只会被以下方法设置：

void quit(boolean safe) {
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }

    synchronized (this) {
        if (mQuitting) {
            return;
        }
        mQuitting = true;
        ...
    }
}

首先是mQuitAllowed标志为false（也就是prepareMainLooper初始化的时候设置为false）的时候直接报错，因为主线程不允许退出looper循环。因为主线程一退出循环，整个应用就退出了。接下来就是设置mQuitting为true，那么说明quit方法的作用也就是退出Looper。

那quit方法什么场景会用到呢？

看下ActivityThread的H的handleMessage方法：

case EXIT_APPLICATION:
	if (mInitialApplication != null) {
		mInitialApplication.onTerminate();
	}
    Looper.myLooper().quit();
    break;

当EXIT_APPLICATION标志的时候便会调用该方法。但是这边有个疑惑：当的时候会报错"Main thread not allowed to quit."，不知道是否是这样子的逻辑。Mark一下。

下面再回到next()方法中的死循环代码块：

标注6处Message msg = mMessages，将当前Message的下一个对象存入msg 。

标注3处当now < msg.when的时候也就是还没到Message执行时间，计算出nextPollTimeoutMillis时间下次循环的时候继续等待。

标注2处nativePollOnce(ptr, nextPollTimeoutMillis)，他的作用是等待nextPollTimeoutMillis毫秒的时间。

标注4处mBlocked = false，注意这个标志。在Handler发送消息会有用到。

标注5处mMessages = msg.next，将当前msg的下一个对象存入mMessages 。

最后就是返回msg。

总的来说就是：如果还没到执行时间那么计算等待时间继续等，如果到了执行时间标志置为false然后返回下一个Message对象。

3、Handler发送消息

发送消息通常有两种方式，贴上代码：

            Handler mHandler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    //doSomething
                }
            };

            mHandler.obtainMessage().sendToTarget();
            
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    //doSomething
                }
            });

首先是Handler的构造函数，贴上代码：

public Handler(Callback callback, boolean async) {
    ...
    mLooper = Looper.myLooper();
    mQueue = mLooper.mQueue;
}

Looper.myLooper()就是从当前线程获取绑定的Looper对象，所以说当在UI线程新建Handler对象的时候不用考虑Looper的问题。接下来就是在该Looper传给mQueue。

首先看下mHandler.obtainMessage().sendToTarget()。

public final Message obtainMessage(){
        return Message.obtain(this);
}

public static Message obtain(Handler h) {
    Message m = obtain();
    m.target = h;

    return m;
}

obtain()是从对象池里面取出一个Message对象避免每次都new对象。然后将mHandler赋值给Message对象的target。

OK！那看下sendToTarget方法：

public void sendToTarget() {
    target.sendMessage(this);//标注1
}

target就是刚才mHandler，而this就是mHandler.obtainMessage()。然后一直跟下去就到了sendMessageAtTime方法。

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);//标注2
    }

标注1的就到了标注2，参数queue就是mHandler构造的时候由线程对应Looper对象获取的。enqueueMessage(queue, msg, uptimeMillis)最终是跑到MessageQueue中的enqueueMessage方法，贴上代码。

boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
		...
        msg.when = when;
        Message p = mMessages;//标注1
        boolean needWake;
        if (p == null || when == 0 || when < p.when) {//标注2
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {//标注3
           ...
            Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    ...
                }
                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;
}

标注1处mMessages就是下一个要执行的Messages对象，将它赋值给p。

标注2处when是当前Message的执行时间而p.when也就是当前MessageQueue里最早的执行时间。

如果when比最早的执行时间还早的话分为两步处理：

第一步就是排到MessageQueue对前面。

第二部是考虑到两种情况。MessageQueue是否正在处理也就是mBlocked是否为false。如果为ture也就是说looper正在阻塞状态那就要利用nativeWake方法唤醒。

标注3处如果when比最晚的执行时间还早的话就按时间先后插入MessageQueue链表中。

OK，下面看下mHandler.post方式发送消息：

public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}

和其他方法大同小异。主要是差在getPostMessage(r)，看下代码：

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

最终也是将Message对象交给MessageQueue中，那么就会执行到dispatchMessage方法。最终会跑到handleCallback方法

private static void handleCallback(Message message) {
    message.callback.run();
}

最终调用了Runnable实现。

跨平台coder

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录