一、前言
其实所谓的消息机制就是handler机制，handle的作用我们都知道，由于我们不能再子线程里面直接更新ui（是为了线程安全这样设计），所以我们通常在主线程创建handler，然后在子线程中使用handler发送我们的信息，然后ui线程会回调到这个信息，这样就可以愉快的改变ui（当然这只是handler的一个功能而已）。
下面我们来进行源码分析，为什么通过handler就可以在子线程发送消息，然后主线程回调改ui了，然后为啥就可以实现线程安全了呢！我们来看一下。
二、消息机制关键的几个主类
1、handler ：进行消息的发送和消息的处理。
2、message：就是我们发送的消息。
3、messageQueue :存储我们消息的集合（链表结构）
4、looper：一个循环体，时刻判断是否messageQueue是否有新消息 有就处理没有就阻塞
三、解析源码
1、handler
首先记住handle里面有3个关键引用：
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;handler是怎么发送消息的，无论调用sendxxx（）还是postxxx（），在handler最终都会调用 sendMessageAtTime方法。
我们看看它的源码
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
//我们看到了MessageQueue被mQueue赋值，我们看看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);
}
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) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();//我们看到mLooper被赋值 Looper.myLooper()调用怎么就得到了
//Looper对象，这个我们看Looper讨论，mLooper是当前Thread的唯一looper（一个线程只有有looper对象）
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;//mQueue原来在这里被赋值啊 那mLooper的mQueue哪里来的啊 我们稍后分析Looper再看
mCallback = callback;
mAsynchronous = async;
}继续往下看 第一图我们看到 return enqueueMessage(queue, msg, uptimeMillis);看看它的源码
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this; //我们看到我们把当前的handler对象赋值给Message对象的target了，干嘛的呢，等会说，哈哈~
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);//咦queue调用自己的方法enqueueMessage了，看来要进入MessageQueue看看了，好进入~
}2、MessageQueue
代码量很多，但是你只要记住这enqueueMessage主要作用是把我们发送的Message插入到链表中
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {//看到这都知道为啥线程安全了吧，插入数据是synchronized
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
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;
}貌似到这里我们加入把Message 插入到 MessageQueue 链表后就不能往下走了
突然想还有一个looper 那我们看看它干了啥
3、looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); //Looper内的static类对象存储当前线程的Looper对象
private static Looper sMainLooper; //主线程的Looper对象
final MessageQueue mQueue;//咦好熟哦，刚才看Hander我们说了Looper的mQueue，原来在这
final Thread mThread;//当前线程对象说到looper我们要继续说下它的功能，循环遍历MessageQueue ，看里面是否有消息， 有就处理 ，没有就阻塞
好，那我们看看Looper怎么初始化的
public static void prepare() {
prepare(true);//初始化，调用我们看看下面
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {//sThreadLocal存储当前线程的looper对象刚才就说了
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));//如果sThreadLocal没有存入当前的线程的looer对象，那么就new它
}看看怎么new looper的
我们看到new Looper干了两件事
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);//new了MessageQueue ，原来mQueue是这么来的啊
mThread = Thread.currentThread();//获取当前线程对象
}突然想到要循环遍历MessageQueue ，那我们看看怎么循环遍历的
我靠又是一大篇，没事我们看看关键点
public static void loop() {
final Looper me = myLooper();//获取当前的myLooper()里面就一句代码 return sThreadLocal.get();，返回当前的线程的looper对象
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue; //获取当前线程的MessageQueue对象
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
final int thresholdOverride =
SystemProperties.getInt("log.looper."
+ Process.myUid() + "."
+ Thread.currentThread().getName()
+ ".slow", 0);
boolean slowDeliveryDetected = false;
for (;;) {//哦豁死循环，死循环那不会卡死啊，不会，看下面一句 queue.next();里面有消息就处理，没有就会阻塞，不会卡死
Message msg = queue.next(); // might block 我们看到MessageQueue取到消息msg然后看下面
if (msg == null) {
return;
}
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
if (thresholdOverride > 0) {
slowDispatchThresholdMs = thresholdOverride;
slowDeliveryThresholdMs = thresholdOverride;
}
final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
final boolean needStartTime = logSlowDelivery || logSlowDispatch;
final boolean needEndTime = logSlowDispatch;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
final long dispatchEnd;
try {
msg.target.dispatchMessage(msg);//我们看到Message调用target，
//它不就是handler对象吗，然后handler调用自己的方法dispatchMessage（msg）把 Message分发下去
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logSlowDelivery) {
if (slowDeliveryDetected) {
if ((dispatchStart - msg.when) <= 10) {
Slog.w(TAG, "Drained");
slowDeliveryDetected = false;
}
} else {
if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
msg)) {
slowDeliveryDetected = true;
}
}
}
if (logSlowDispatch) {
showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();
}
}上面我们看到了handler调用dispatchMessage传递下去了，那我们继续看看hander吧
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//如果Message中的callback不为空，自己调用自己的回调方法
handleCallback(msg);
} else {
if (mCallback != null) {//如果hander中mCallback不未空，回调，这样就可以在创建的线程回调到msg了
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//自己回调
}
}好了我们大致知道handler在子线程发送了Message（发送的时候里面要保存了发送它的handler的引用）到MessageQueue 链表中，looper一直遍历MessageQueue，当它发现MessageQueue 里面有新消息的时候，就会调用MessageQueue next（）方法，这个方法中有消息时就返回Message，没有就阻塞，释放cup资源，所以不会卡死。如果取到消息就用发送该消息的hander调用dispatchMessage方法，然后创建handler的线程就回调了子线程发送的消息。
这个时候你肯定还有疑问Looer是在哪被调用prepare（）创建looper对象、在哪调用loop（）开始循环的呢。
我都都说主线程也就是ui线程 ，其实是在主线程中系统帮我们创建好了。
在ActivityThread的main创建了主线程Looper 并开始了循环
public static void main(String[] args) {
Looper.prepareMainLooper();//创建主线程的looper对象
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();//开启循环
throw new RuntimeException("Main thread loop unexpectedly exited");
}
其实上面我们对app所做的所有操作都在这个主线程的Lopper的循环中进行
其实我们平常打开一个activity它的生命周期 都是什么创建啊销毁啊都是在
子程序运行的 只是完成后会通过handler发送消息被主线程回调到，所以你应该
知道为啥安卓消息机制是handler机制了吧
by the way ，已经说了主线程系统帮我们创建了looper对象 并循环跑起来，所以我们可以在主线程中创建handler，如果你要在子线程中创建handler 就要自己创建looper对象并开启循环哦。
四、总结
没啥好总结的，放一张以前看到的一篇文章的图，感觉很形象的说明的hander机制
好了，如果有问题请留言，拜~
扫一扫
916
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
