前言:
android的消息机制主要是指Handler的运行机制,Handler的运行,需要底层的MessageQueue和Looper来配合完成.
Handler 的主要作用:
主要负责post或者send消息(查看源码发现,post最后也是调用send发送消息) 到MessageQueue消息队列里面
最后再Looper里面会调用dispatchMessage()方法,将代码逻辑切换到指定的线程中去执行.
MessageQueue: (消息队列)的主要作用:
底层不是队列,而是由单链表结构组成,因为MessageQueue主要负责插入和读取,单链表这方面速度快
主要有两个操作:
插入消息(enqueueMessage): 源码实现,就是单链表的一些插入操作
读取消息(next): 源码实现,next就是一个无限循环的方法,如果消息队列没有消息,next方法就会阻塞.等有新的消息到来,next方法会返回这条新的消息并且在单链表中移除.
Looper的主要作用:
Looper主要负责消息循环,Looper会不停的从MessageQueue里面查看是否有新的消息,如果有新的消息就会立刻处理,否则就一直阻塞在这里.
ThreadLocal的主要作用:
ThreadLocal在整个消息循环中也是比较重要的,ThreadLocal 是一个线程内部的数据存储的泛型类 ThreadLocal 内部有一个Object[ ] table 来存储各种类型的值,在整个消息处理过程,ThreadLocal 用来保存每个线程的Looper对象,
ThreadLocal的使用:当不同线程有不同的数据的时候时候,比如消息循环过程,保存每个线程的Looper对象
final ThreadLocal<Boolean> boThreadLocal = new ThreadLocal<>();
boThreadLocal.set(true);
new Thread("Thread#1"){
@Override
public void run() {
boThreadLocal.set(false);
Log.d(TAG, "[thread_1]: boThreadLocal = " + boThreadLocal.get());
}
}.start();
new Thread("Thread#2"){
@Override
public void run() {
boThreadLocal.set(null);
Log.d(TAG, "[thread_2]: boThreadLocal = " + boThreadLocal.get());
}
}.start();
Log.d(TAG, "[thread_main]: boThreadLocal = " + boThreadLocal.get());
打印结果可以看过,不同的线程,里面存储的信息是不同的:
ThreadLocal 的工作原理
.有两个比较重要的方法,get() 和 set() .弄清楚这两个方法就能明白ThreadLocal 的工作原理
set() 方法:
public void set(T value) {
Thread thread = Thread.currentThread();
ThreadLocalMap map = getMap(thread);
if (map != null)
map.set(this, value);
else
createMap(thread , value);
}
通过Thread.currentThread()获取当前的线程 thread ,然后通过当前线程 thread 获取里面的 ThreadLocalMap 对象 map 来存储数据, map.set(this, value); 内部是用一个 Entry[ ] tab 数组来存储信息. 到这里不用管是什么逻辑,反正相当于用一个Object[ ] tab 数组管理一下数据
Entry 是继承Object然后再继承WeakReference 的一个类,这里把Entry当做Object来使用就可以.
map.set(this, value):
private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i] ; e != null; e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//最后将当前的ThreadLocal 和 value存储起来
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
看一下new Entry(key, value); 的构造:
如下图,可以看到,这里声明了一个全局变量 Object 对象value来存储对应的ThreadLocal 的值value
Object value;
Entry(ThreadLocal key, Object value) {
super(key);
this.value = value;
}
Entry 是什么鬼?
Entry 是继承 WeakReference 的类,这里姑且把它理解为Object使用.
看一下get()方法:
get() 方法:
public T get() {
Thread thread = Thread.currentThread();
ThreadLocalMap map = getMap(thread );
if (map != null) {
ThreadLocalMap.Entry entry = map.getEntry(this);
if (entry != null)
return (T)entry.value;
}
return setInitialValue();
}
get方法和set方法一样,也是先获取当前的线程 thread,再获取到ThreadLocalMap 对象map.再通过map.getEntry(this) 方法获取** entry** 对象,如果entry 对象是null,就直接返回 setInitialValue(),而setInitialValue()方法默认实现是直接返回null, 否则就获取里面存储的值 value,而entry.value就是上面set()方法中 最后new Entry(key, value) 声明的全局变量保存的value,到这里,就能看到怎样获取到ThreadLocal 对应的value了.
MessageQueue 消息队列的工作原理:
MessageQueue 消息队列主要有两个功能.插入和读取:
enqueueMessage的源码:
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
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; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
enqueueMessage 这里不管它怎么实现了(暂时看不懂),就记住是单链表插入数据的操作算法
看一下另外比较重要的 next 读取方法
next的源码:
Message next() {
...
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
//获取系统开机到现在的时间,当系统进入深度睡眠（CPU休眠,屏幕休眠,设备等待外部输入）时间就会停止
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.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
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;
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
//这里是唯一控制looper退出的地方
if (mQuitting) {
dispose();
return null;
}
...
}
}
next 方法里面有一个无限循环,如果消息队列没有消息,next就阻塞在这里,当有新的消息的时候,next方法会返回这条消息并且将其从消息队列的单链表里面移除.
另外看到最后面判断当前是否mQuitting,next只有当调用quit或者quitSafely的时候mQuitting才会为true,也只有这个是否会返回null,控制Looper的loop死循环跳出.
MessageQueue 消息队列就这两个主要的功能...
Looper的工作原理:
Looper的构造:
创建Looper的时候会初始化MessageQueue对象mQueue ,并且记录当前的线程 mThread;
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Handler的工作不管是post还是send 最后都会调用sendMessageAtTime()方法,当中会做一个判断,mQueue对象为null的话就会抛出异常,而这个mQueue就是上面Looper的构造里面的mQueue 对象.所以可以看出整个消息机制中,Handler的工作是离不开Looper和MessageQueue的
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
怎样为一个线程创建一个Looper?
Android 在进程的入口函数 ActivityThread.main()中，就已经调用 Looper.prepareMainLooper, 为应用的主线程创建Looper，然后调用Looper.loop()就启动了进程的消息循环，然后我们平时才可以在一些Activity中直接使用new Handler(),来处理消息了.
public static void main(String[] args) {
...
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
Looper.loop();
}
默认情况下一个线程是不存在消息循环(MessageQueue和loop)的，需要调用Looper.prepare()来给线程创建一个消息循环，调用Looper.loop()来使消息循环起作用，从消息队列里取消息进行处理.
new Thread("Thread#007"){
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}.start();
看一下 prepare的源码实现:
首先判断一下sThreadLocal.get()!=null,如果当前线程的ThreadLocal.get()获取到的Looper信息不为空,就抛异常,ThreadLocal对象.上面解释了,就是用来存储每个线程的独立信息的,能区分每个线程取出来的值都是不同的.
然后再把当前的Looper对象做为value,设置进去存储.
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));
}
Looper还有一个prepareMainLooper,就是上面系统为主线程创建Looper调用的,其实也是一样调用prepare(false)实现的.
Looper还为主线程提供了一个getMainLooper()方法,在任何线程都能调用它,获取主线程的Looper对象.
看一下最重要的循环方法loop
调用了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;
...
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) { //这里是跳出循环的地方
// No message indicates that the message queue is quitting.
return;
}
...
try {
msg.target.dispatchMessage(msg);
} finally {
...
}
...
}
Looper.loop就是一个死循环,先获取到消息队列queue ,然后从queue.next()方法中读取消息,只有消息为null的时候才会跳出循环.什么时候queue.next()会返回null?当Looper的quit方法被调用,Looper就会调用MessageQueue的quit或者quitSafely方法,通知消息队列,这个时候MessageQueue的next才会返回null, 否则会一直阻塞在next方法等待消息.所以Looper要么就是退出,要么就一直循环下去.
这里可以看到,Looper处理消息是调用msg.target.dispatchMessage(msg)来分派消息给handler处理,而Handler的dispatchMessage方法,是在创建Handler时,使用的线程中执行的.这样就把逻辑转到指定的线程了.
msg.target赋值 在Handler发送消息会调用的enqueueMessage方法中
Looper的退出:
Looper提供了两个方法退出,quit和quitSafely
quit和quitSafely的区别:
quit被调用会直接Looper
quitSafely只是设定一个退出的标记,等消息队列中的消息处理完了才安全的退出
Looper退出之后,Handler发送的消息就会失败,在子线程中,我们手动创建了Looper来处理事情.那么在所有的任务做完的时候就应该调用quit方法来退出消息循环.否则这个子线程会一直处于等待的状态.
(如果Looper退出了,这个线程就会立刻终止)
Handler的工作原理:
Handler主要是用来发送和接受消息的过程.发送就是通过post一系列方法,或者send一系列方法来实现.不管是post或者send,最后都是调用enqueueMessage方法,然后调用MessageQueue的enqueueMessage向消息队列里面插入一条消息.然后就是MessageQueue消息队列会讲这条消息返回给Looper,在上面已经知道,最后Looper还是分派给Handler的dispatchMessage方法处理.
dispatchMessage方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这里逻辑比较简单,Message 里面的callback 不为null,就交给handleCallback(msg)处理,最后就回调到了callback里面的run方法.比如我们post(new Runnable ...)的Runnable里面的run方法
private static void handleCallback(Message message) {
message.callback.run();
}
否则就判断一下mCallback != null , mCallback 就是平时使用new Handler(Callback callback)的时候的callback.比如我们平时使用的:
public Handler(Callback callback, boolean async) {
...
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
private Handler h = new Handler(){
@Override
public void handleMessage(Message msg) {
//回调到这里
}
};
这就是Android 整个消息处理过程
