登录 立即注册
安币:

安卓巴士 - 安卓开发 - Android开发 - 安卓 - 移动互联网门户

查看: 266|回复: 0

你真的了解Handler吗?扶我上墙,我来告诉你

[复制链接]

39

主题

331

帖子

2475

安币

Android大神

Rank: 6Rank: 6

发表于 2018-1-12 14:25:01 | 显示全部楼层 |阅读模式
如果对本篇文章感兴趣,请前往,原文地址:http://www.apkbus.com/blog-302849-76865.html

被吹烂的Handler,我来再实锤一波。话不多讲,步入正题。## 消息循环机制我们都知道,Android应用程序是通过消息来驱动的,整个机制是围绕着消息的产生以及处理而展开的。消息机制的三大要点:消息队列、消息循环(分发)、消息发送与处理。### 1. 消息队列Android应用程序线程的消息队列是使用一个MessageQueue对象来描述的,它可以通过调用Looper类的静态成员函数`prepareMainLooper`或者`prepare`来创建,其中,前者用来为应用程序的主线程创建消息队列;后者用来为应用程序的其它子线程创建消息队列。- 创建消息队列`prepareMainLooper`和`prepare`的实现:```public static void prepare() {        prepare(true);    }    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还是在其它线程中,最终调用的方法都是`prepare(boolean quitAllowed)`方法,进一步来看下具体实现。```private static void prepare(boolean quitAllowed) {        if (sThreadLocal.get() != null) {            throw new RuntimeException("Only one Looper may be created per thread");        }        //当前线程创建唯一的loop对象        sThreadLocal.set(new Looper(quitAllowed));    }```程序最后一行中,为当前的线程创建唯一的loop对象。loop的构造方法如下:```private Looper(boolean quitAllowed) {        //创建消息队列        mQueue = new MessageQueue(quitAllowed);        mThread = Thread.currentThread();    }```程序到了上面后开始创建消息队列,MessageQueue的构造方法如下:```MessageQueue(boolean quitAllowed) {        mQuitAllowed = quitAllowed;        //调用JNI方法创建消息队列        mPtr = nativeInit();    }```可以发现java层的MessageQueue是由JNI层的`nativeInit`方法实现的。> 到了JNI层IDE上面就看不到具体实现了,这里推荐一个在线的源码阅读地址:[点击查看](http://androidxref.com/)在`/frameworks/base/core/jni/android_os_MessageQueue.cpp`找到`android_os_MessageQueue.cpp`文件,这里我们先看`nativeInit`方法的实现```sp android_os_MessageQueue_getMessageQueue(JNIEnv* env, jobject messageQueueObj) {    //java 层messageQueue与当前JNI的MessageQueue关联   jint intPtr = env->GetIntField(messageQueueObj, gMessageQueueClassInfo.mPtr);    return reinterpret_cast(intPtr);}static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {   NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();   if (!nativeMessageQueue) {        jniThrowRuntimeException(env, "Unable to allocate native queue");       return 0;    }    //强引用计数加1    nativeMessageQueue->incStrong(env);    //将指针强转化为java long类型    return reinterpret_cast(nativeMessageQueue);}```在C  层,实现Java层的MessageQueue新建了NativeMessageQueue与java层的相关联,并将生成的nativeMessageQueue的内存地址返回到java层。在NativeMessageQueue的构造方法中,新建了JNI层的loop对象:```NativeMessageQueue::NativeMessageQueue() :       mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {    mLooper = Looper::getForThread();    if (mLooper == NULL) {          //创建JNI层的Looper对象        mLooper = new Looper(false);        Looper::setForThread(mLooper);   }}```找到路径`/system/core/libutils/Looper.cpp`,我们来看Looper的具体实现。```Looper::Looper(bool allowNonCallbacks) :        mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),        mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {    int wakeFds[2];//准备两个文件描述符    int result = pipe(wakeFds);//创建一个管道    LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);    mWakeReadPipeFd = wakeFds[0];//管道读端文件描述符    mWakeWritePipeFd = wakeFds[1];//管道写端文件描述符    result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);//将管道读端设为非阻塞模式    LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",            errno);    result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);//管道写端同样设为非阻塞    LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",            errno);    mIdling = false;    // Allocate the epoll instance and register the wake pipe.    mEpollFd = epoll_create(EPOLL_SIZE_HINT);//创建一个epoll专用的文件描述符    LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);            //epoll其中一个专用结构体    struct epoll_event eventItem;    //把结构体清零    memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union    //重新赋值    eventItem.events = EPOLLIN;//EPOLLIN :表示对应的文件描述符可以读;    eventItem.data.fd = mWakeReadPipeFd;//fd:关联的文件描述符;    //epoll_ctl函数用于控制某个epoll文件描述符上的事件,可以注册事件,修改事件,删除事件。这里是添加事件     result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, & eventItem);    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",            errno);}```上述代码中创建的管道非常的重要,它又两个文件描述符:`mWakeReadPipeFd`(管道读端文件描述符)和`mWakeWritePipeFd`(管道写端描述符)。首先,当一个线程没有新的消息处理时,它就会睡眠在这个管道的读端文件描述符上,直到有新的消息需要处理为止;其次,当其它线程向这个线程的消息队列发送一个消息之后,其它线程就会通过这个管道的写端文件描述符往这个管道写入数据,,从而将这个线程唤醒,以便它可以对刚才发送到它的消息队列中的消息进行处理。> epoll是Linux内核为处理大批量文件描述符而作了改进的poll,是Linux下多路复用IO接口select/poll的增强版本,它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。另一点原因就是获取事件的时候,它无须遍历整个被侦听的描述符集,只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。epoll除了提供select/poll那种IO事件的水平触发(Level Triggered)外,还提供了边缘触发(Edge Triggered),这就使得用户空间程序有可能缓存IO状态,减少epoll_wait/epoll_pwait的调用,提高应用程序效率。后面在回答为什么死循环不会导致app卡死也是利用了这机制的这个特点。### 2. 消息循环过程在looper中建立完毕消息队列后,就会进入循环了,我们这里来看下looper的静态方法`Looper.loop()`,为了不影响阅读我把理解都加到代码的注释中,之外就不做过多解释。```public static void loop() {        final Looper me = myLooper();        if (me == null) {            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        final MessageQueue queue = me.mQueue;       ················       //进入死循环,获取message并处理它        for (;;) {            //从队列中获取下一个消息            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                如果没有消息循环中止                return;            }           ················                       msg.target.dispatchMessage(msg);                      ················            //回收消息即便还在使用            msg.recycleUnchecked();        }    }```我们都知道消息队列是遵循先进先出的,那么为什么会这样呢?我们开看下Message的结构:```    /*package*/ int flags;    /*package*/ long when;        /*package*/ Bundle data;        /*package*/ Handler target;        /*package*/ Runnable callback;        // sometimes we store linked lists of these things    /*package*/ Message next;//链表结构    private static final Object sPoolSync = new Object();    private static Message sPool;//本地静态变量,可避免创建多个Messager    private static int sPoolSize = 0;    private static final int MAX_POOL_SIZE = 50;        public static Message obtain() {        synchronized (sPoolSync) {            if (sPool != null) {                Message m = sPool;                sPool = m.next;                m.next = null;                m.flags = 0; // clear in-use flag                sPoolSize--;                return m;            }        }        return new Message();    }```不难发现,Message是链表结构。回归正题,我们接着看MessageQueue如何取Message的```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) {            return null;        }        //等待的闲置Handdler的数目        int pendingIdleHandlerCount = -1; // -1 only during first iteration        //下一个消息执行需要的时间        int nextPollTimeoutMillis = 0;        for (;;) {            if (nextPollTimeoutMillis != 0) {                //进入睡眠状态时,将当前线程中挂起的所有Binder命令刷新到内核驱动程序                Binder.flushPendingCommands();            }            //检查当前线程是否有新的消息需要处理,具体实现下面会讲            nativePollOnce(ptr, nextPollTimeoutMillis);            synchronized (this) {                // Try to retrieve the next message.  Return if found.                final long now = SystemClock.uptimeMillis();                Message prevMsg = null;                Message msg = mMessages;//取出表头                if (msg != null && msg.target == null) {                    // Stalled by a barrier.  Find the next asynchronous message in the queue.                    //当前消息的Handler处理器为空,证明这是个barrier,会拦截当前的队列,直到不是异步消息为止。                    do {                        prevMsg = msg;                        msg = msg.next;                    } while (msg != null && !msg.isAsynchronous());                }                if (msg != null) {                    if (now < msg.when) {                        // 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;                        if (prevMsg != null) {                            prevMsg.next = msg.next;                        } else {                            mMessages = msg.next;                        }                        msg.next = null;                        if (DEBUG) Log.v(TAG, "Returning message: "   msg);                        msg.markInUse();                        return msg;                    }                } else {                    // No more messages.                    nextPollTimeoutMillis = -1;                }                // Process the quit message now that all pending messages have been handled.                if (mQuitting) {                    dispose();                    return null;                }                // If first time idle, then get the number of idlers to run.                // Idle handles only run if the queue is empty or if the first message                // in the queue (possibly a barrier) is due to be handled in the future.                //当线程发现它的消息队列没有新的消息需要处理时,不是马上就进入睡眠等待状态,而是先调用注册到它的消息队列中的IdleHandler对象的成员函数queueIdle,一遍它们有机会在线程空闲时执行一些操作。                if (pendingIdleHandlerCount < 0                        && (mMessages == null || now < mMessages.when)) {                    pendingIdleHandlerCount = mIdleHandlers.size();                }                if (pendingIdleHandlerCount pollOnce(env, obj, timeoutMillis);}···········void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {    ··········    //mLooper指向了一个C  层的Looper对象,这里调用其成员函数pollOnce来检查当前线程是否有新的消息需要处理    mLooper->pollOnce(timeoutMillis);    ··········    }```继续找到路径`/system/core/libutils/Looper.cpp`:```int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {    int result = 0;    for (;;) {            ······                if (result != 0) {        ······            return result;        }        result = pollInner(timeoutMillis);    }}······int Looper::pollInner(int timeoutMillis) {     ······    // Poll.    int result = POLL_WAKE;        ······    //监听在Looper构造方法中创建的epoll实例的文件描述符的IO读写事件    struct epoll_event eventItems[EPOLL_MAX_EVENTS];    //如果这些文件描述符都没有发生IO读写书剑,那么当前线程就会进入等待状态,等待时间由timeoutMillis来指定    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);    ······    //循环检查哪一个文件描述符发生了IO读写事件    for (int i = 0; i < eventCount; i  ) {        int fd = eventItems.data.fd;        uint32_t epollEvents = eventItems.events;        //检查是否是当前线程管道的读端文件描述符        if (fd == mWakeEventFd) {            //是否写入了新的数据            if (epollEvents & EPOLLIN) {                //读取当前线程关联的管道的数据                awoken();            }            ······        }        ······    }    ······    return result;}······void Looper::awoken() {······    uint64_t counter;    //将与当前线程所关联的管道数据读出来,以便可以清理这个管道的就数据。    TEMP_FAILURE_RETRY(read(mWakeEventFd, &counter, sizeof(uint64_t)));}```### 3. 消息发送与处理在前面插播了Message的结构体介绍,那么作为链表的表头它是在什么时候给赋值的呢?下面我们来一起看下Handler是如何做到消息发送以及处理的。首先是Handler的构造函数:```public class Handler {    ······    final Looper mLooper;    final MessageQueue mQueue;    final Callback mCallback;    final boolean mAsynchronous;    ······   public Handler(Callback callback, boolean async) {        if (FIND_POTENTIAL_LEAKS) {            final Class
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

站长推荐

通过邮件订阅最新安卓weekly信息
上一条 /4 下一条

下载安卓巴士客户端

全国最大的安卓开发者社区

广告投放| 下载客户端|申请友链|手机版|站点统计|安卓巴士 ( 粤ICP备15117877号 )

快速回复 返回顶部 返回列表