Android中Handler机制浅谈

2017-07-18  本文已影响0人  codingwz

Android中的Handler一般是用于异步任务，和Handler相关的一些概念有Looper，MessageQueue，下面先通过一张图来展示三者只之间的关系。


MessageQueue主要是维护消息队列，Handler主要是消息的发送和处理，Looper扮演着管理者这么一个角色，由它来维护这个流程的正常执行。
首先来分析一下这个管理者Looper，它是一个线程独享的变量，所以再此之间还得先了解一个概念ThreadLocal，这是Android系统提供的一个类，用于实现线程独享。

同样get的逻辑也很清楚，首先获得当前线程，然后获得一个Values变量，通过values中的table属性来获得所需的值。
set和get中都出现了一个类Value，接下来看一下Value这个类。Values是ThreadLocal的静态内部类，我们主要关注一下其中的table属性，put和value方法。
Values values(Thread current) {
return current.localValues;
}
values方法非常简单，就是获得当前线程的localValues变量。而localValues变量就是Thread类中的一个属性。
Thread { ThreadLocal.Values localValues; } 想必看到这就明白为什么在不同线程环境下能够获得各自线程的本地变量了。因为实质上就是在每个Thread内部存储了一个本地变量，通过空间来换时间达到同步的作用。
static class Values {
/**
* Map entries. Contains alternating keys (ThreadLocal) and values.
* The length is always a power of 2.
*/
private Object[] table;

      void put(ThreadLocal<?> key, Object value) {
        cleanUp();

        // Keep track of first tombstone. That's where we want to go back
        // and add an entry if necessary.
        int firstTombstone = -1;

        for (int index = key.hash & mask;; index = next(index)) {
            Object k = table[index];

            if (k == key.reference) {
                // Replace existing entry.
                table[index + 1] = value;
                return;
            }

            if (k == null) {
                if (firstTombstone == -1) {
                    // Fill in null slot.
                    table[index] = key.reference;
                    table[index + 1] = value;
                    size++;
                    return;
                }

                // Go back and replace first tombstone.
                table[firstTombstone] = key.reference;
                table[firstTombstone + 1] = value;
                tombstones--;
                size++;
                return;
            }

            // Remember first tombstone.
            if (firstTombstone == -1 && k == TOMBSTONE) {
                firstTombstone = index;
            }
        }
      }
  }

table变量很简单，就是一个Object数组，用于存储所需的值。接下来分析一下put方法。主体就是一个for循环，遍历所有的index，可以把index当做映射关系中的键，通过对应的键最终取到需要的值。
private static AtomicInteger hashCounter = new AtomicInteger(0); private final int hash = hashCounter.getAndAdd(0x61c88647 * 2); //Weak reference to this thread local instance. private final Reference<ThreadLocal<T>> reference = new WeakReference<ThreadLocal<T>>(this);
把table作为键值的存储结构，index下标所对应的为键，index + 1下标所对应的为实际存储的值。
如果k已经存在，就直接更新它的值。如果k不存在，就把key.reference存入table中的index下标位置，把值存在table中index + 1的下标位置。

mMessages是MessageQueue中的属性，它指向消息队列的头部，即下一刻需要处理的消息。这里第一个if判断需要添加新的头部。条件1是当前队列为空，条件2是当前加入的消息为立刻处理，条件3是当前加入的消息比队列首部的消息优先级高（通过消息需要触发时的时间先后来判断）。三者任意一个满足，就需要把当前消息作为头部加入消息队列。
如果不满足，则进入else部分。通过一个for循环，把消息插入到队列的中间，具体的位置是根据优先级来判断。
这样消息的插入就完成了。接下来分析如何取出消息（核心代码）：
Message next() {
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
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;
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;
            }              
    }
  }

方法的主体就是一个for无限循环体，这也就解释了为什么在Looper中调用MessageQueue的next方法会阻塞了。now是系统当前的时间，msg即当前的头部消息，如果不为空，且msg.when 大于 now，即说明当前消息还没有到需要处理的时候，那么让线程挂起。等待nextPollTimeoutMillis 时间后，唤醒线程继续处理消息。
如果消息已经可以处理，那么移动头部引用mMessage为msg的下一个，然后返回当前消息。
至此，消息的添加和取出的逻辑已经分析完毕。

这两个方法很简单，最终会进入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);
}
这个方法同样逻辑非常简单，那么再进入enqueueMessage方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这里终于出现了msg.target = this，原来handler是在发送消息的时候关联到具体的msg上的。
最后调用了queue的enqueueMessage方法，这个方法已经在上边分析过了。
下边来分析一下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);
  }

同样，最终还是会调用sendMessageAtTime这个方法。

上一篇下一篇

猜你喜欢

热点阅读