提到消息機(jī)制，想必大家都不陌生吧诵竭，在日常開發(fā)中不可避免要涉及到這方面的內(nèi)容直晨。從開發(fā)的角度來說，Handler是Android的消息機(jī)制的上層接口症虑，這使得在開發(fā)過程中只需要和Handler交互即可缩歪。Handler的使用過程很簡(jiǎn)單，通過它可以輕松地將一個(gè)任務(wù)切換到Handler所在的線程中去執(zhí)行谍憔。由于Android的開發(fā)規(guī)范的限制匪蝙，我們并不能在子線程中訪問UI控件，否則就會(huì)觸發(fā)程序異常习贫，這個(gè)時(shí)候通過Handler就可以將更新的UI的操作切換到主線程中執(zhí)行逛球，因此從本質(zhì)上來來說，Handler并不是專門用于更新UI的苫昌，它只是常被開發(fā)者用來更新UI颤绕。
Android中的消息機(jī)制主要指Handler的運(yùn)行機(jī)制，Handler的運(yùn)行需要底層的MessageQueue和Looper的支撐祟身。MessageQueue翻譯過來就是消息隊(duì)列奥务，它內(nèi)部存儲(chǔ)了一組消息，以隊(duì)列的形式對(duì)外提供插入和刪除的過程袜硫，雖然叫做消息隊(duì)列氯葬，但是它內(nèi)部存儲(chǔ)結(jié)構(gòu)并不是真正的隊(duì)列，而是采用單鏈表的數(shù)據(jù)結(jié)構(gòu)來存儲(chǔ)消息列表婉陷，Looper翻譯過來就是循環(huán)帚称，這里可以理解為消息循環(huán)。由于MessageQueue只是一個(gè)消息的存儲(chǔ)單元憨攒，它不能去處理消息世杀，而Looper填補(bǔ)了這個(gè)功能阀参，Looper會(huì)無限循環(huán)的形式去查找是否有新的消息肝集，如果有的話就處理消息，否則就中一直等待蛛壳。Looper中還有一個(gè)特殊的概念杏瞻，那就是ThreadLocal，Threadlocal并不是線程衙荐，它的作用是可以在每個(gè)線程中存儲(chǔ)數(shù)據(jù)捞挥。
我們知道，Handler創(chuàng)建的時(shí)候會(huì)采用當(dāng)前線程的Looper來構(gòu)造消息循環(huán)系統(tǒng)忧吟，那么Handler內(nèi)部如何獲取到當(dāng)前線程的Looper呢砌函，這就要使用ThreadLocal了，ThreadLocal可以在不同的線程中互不干擾地存儲(chǔ)并提供數(shù)據(jù)，通過ThreadLocal可以輕松獲取每個(gè)線程的Looper讹俊。需要注意的是垦沉，線程是默認(rèn)沒有Looper的，如果需要使用Handler就必須為線程創(chuàng)建Looper仍劈，我們經(jīng)常提到的主線程厕倍，也叫UI線程，它就是ActivityThread贩疙，ActivityThread被創(chuàng)建時(shí)就會(huì)初始化Looper讹弯，這也是在主線程中默認(rèn)可以使用Handler的原因。
Android的消息機(jī)制概述
我們知道Handler的主要作用是將一個(gè)任務(wù)切換到某個(gè)指定的線程中去執(zhí)行这溅，那么Android為什么要提供這個(gè)功能呢组民，這是因?yàn)锳ndroid規(guī)定訪問UI只能在主線程中進(jìn)行，如果子線程中訪問UI芍躏，那么程序就會(huì)拋出異常邪乍。
void checkThread() {
if (mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
}
這是ViewRootImpl的checkThread方法，從這段代碼就可以看出对竣，如果不在當(dāng)前線程庇楞，就會(huì)拋出異常。同時(shí)呢否纬，Android不建議在主線程中進(jìn)行耗時(shí)操作吕晌， 否則會(huì)導(dǎo)致程序無法響應(yīng)，即ANR临燃。那么系統(tǒng)為什么允許在子線程中訪問UI呢睛驳，這是因?yàn)锳ndroid中的UI控件并不是線程安全，它同時(shí)也延伸了Java系統(tǒng)中默認(rèn)進(jìn)程的話會(huì)產(chǎn)生默認(rèn)的單線程習(xí)慣膜廊，當(dāng)用戶點(diǎn)擊乏沸、滑動(dòng)等事件操作時(shí)，UI線程是負(fù)責(zé)分發(fā)的爪瓜，統(tǒng)一管理會(huì)更高效點(diǎn)蹬跃，采取單線程來處理UI操作，對(duì)于開發(fā)者來說也不是很麻煩铆铆，只是需要通過Handler切換下UI訪問的執(zhí)行線程即可蝶缀。
簡(jiǎn)單描述下Handler的工作原理，Handler創(chuàng)建完畢后薄货，這個(gè)時(shí)候內(nèi)部的Looper以及MessageQueue就可以和Handler一起協(xié)同工作翁都，然后通過Handler的post方法將一個(gè)Runnable投遞到Handler內(nèi)部的Looper中去處理，也可以通過Handler的send方法發(fā)送一個(gè)消息谅猾，這個(gè)消息同樣會(huì)在Looper中去處理柄慰。
Android消息機(jī)制分析
先看下整體的架構(gòu)圖：
整體UML圖
- Looper有一個(gè)MessageQueue消息隊(duì)列
- MessageQueue有一組待處理的Message
- Message中有一個(gè)用于處理消息的Handler
- Handler中有Looper和MessageQueue
Looper的工作原理
Looper在Android的消息機(jī)制扮演著消息循環(huán)的角色鳍悠，具體來說就是它會(huì)不停地從MessageQueue中查看是否有新消息過來，如果有新的消息的就會(huì)立刻處理坐搔，否則就一直阻塞在那里贼涩。首先看下它的構(gòu)造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在構(gòu)造方法中，它會(huì)創(chuàng)建一個(gè)MessageQueue對(duì)象薯蝎，然后將當(dāng)前線程的對(duì)象給保存起來遥倦。我們知道，Handler的工作需要Looper占锯，沒有Looper線程就會(huì)報(bào)錯(cuò)袒哥，那么如何為一個(gè)線程創(chuàng)建Looper呢，有以下方法：
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));
}
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
從中我們可以看出消略，每個(gè)線程只有一個(gè)Looper堡称，多創(chuàng)建一個(gè)會(huì)報(bào)錯(cuò)，然后prepareMainLooper這個(gè)方法主要給主線程也就是ActivityThread創(chuàng)建Looper使用艺演，其本質(zhì)也是通過prepare方法來實(shí)現(xiàn)的却紧。
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
Looper提供了quit和quitSafely方法退出一個(gè)Looper，這兩者最主要區(qū)別在于一個(gè)設(shè)定退出標(biāo)記胎撤，一個(gè)是把消息隊(duì)列中的已有消息處理完畢后才安全地退出晓殊。
當(dāng)然還有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;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
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();
}
}
這個(gè)也比較好理解伤提，loop方法是一個(gè)死循環(huán)巫俺，唯一跳出循環(huán)的方式就是MessageQueue的next方法返回了null。Looper就會(huì)調(diào)用MessageQueue的quit或者quitSafely方法來通知消息隊(duì)列退出肿男，當(dāng)消息隊(duì)列被標(biāo)記為退出狀態(tài)時(shí)介汹，它的next方法就會(huì)返回null，也就是說looper必須退出舶沛，否則loop方法就會(huì)無限循序下去嘹承。
MessageQueue工作原理
在Android中MessageQueue主要包含兩個(gè)操作：插入和讀取。讀取操作本身會(huì)伴隨著刪除操作如庭，插入和讀取對(duì)應(yīng)的方法分別為enqueueMessage和next叹卷，其中enqueueMessage的作用是往消息隊(duì)列中插入一條消息，而next的作用是從消息隊(duì)列中取出一條消息并將其從消息隊(duì)列中移除柱彻。在MessageQueue內(nèi)部通過一個(gè)單鏈表的數(shù)據(jù)結(jié)構(gòu)來維護(hù)消息列表豪娜，單鏈表在插入和刪除上比較有優(yōu)勢(shì)餐胀。
看下enqueueMessage代碼：
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) {
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 {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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;
}
主要操作其實(shí)就是單鏈表的插入操作哟楷。
看下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) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
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.
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.
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}
可以發(fā)現(xiàn)next方法就是一個(gè)無限循環(huán)的方法，如果消息隊(duì)列中沒有消息否灾，那么next方法就會(huì)一直阻塞在這里卖擅，當(dāng)有新消息到來時(shí)，next方法會(huì)返回這條消息并將其從單鏈表中移除。
Message
每個(gè)消息用Message表示惩阶，Message主要包含以下內(nèi)容：
| 數(shù)據(jù)類型 | 成員變量 | 解釋 |
|---|---|---|
| int | what | 消息類別 |
| long | when | 消息觸發(fā)時(shí)間 |
| int | arg1 | 參數(shù)1 |
| int | arg2 | 參數(shù)2 |
| Object | obj | 消息內(nèi)容 |
| Handler | target | 消息響應(yīng)方 |
| Runnable | callback | 回調(diào)方法 |
創(chuàng)建消息的過程挎狸，就是填充消息的上述內(nèi)容的一項(xiàng)或多項(xiàng)。
消息池
在代碼中断楷，可能經(jīng)诚谴遥看到recycle()方法，咋一看冬筒，可能是在做虛擬機(jī)的gc()相關(guān)的工作恐锣，其實(shí)不然，這是用于把消息加入到消息池的作用舞痰。這樣的好處是土榴，當(dāng)消息池不為空時(shí)，可以直接從消息池中獲取Message對(duì)象响牛，而不是直接創(chuàng)建，提高效率。
靜態(tài)變量sPool的數(shù)據(jù)類型為Message背蟆，通過next成員變量豌研，維護(hù)一個(gè)消息池；靜態(tài)變量MAX_POOL_SIZE代表消息池的可用大斜岽浴坯台；消息池的默認(rèn)大小為50。
消息池常用的操作方法是obtain()和recycle()瘫寝。
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null; //從sPool中取出一個(gè)Message對(duì)象蜒蕾，并消息鏈表斷開
m.flags = 0; // 清除in-use flag
sPoolSize--; //消息池的可用大小進(jìn)行減1操作
return m;
}
}
return new Message(); // 當(dāng)消息池為空時(shí)，直接創(chuàng)建Message對(duì)象
}
obtain()焕阿，從消息池取Message咪啡，都是把消息池表頭的Message取走，再把表頭指向next暮屡。
public void recycle() {
if (isInUse()) { //判斷消息是否正在使用
if (gCheckRecycle) { //Android 5.0以后的版本默認(rèn)為true,之前的版本默認(rèn)為false.
throw new IllegalStateException("This message cannot be recycled because it is still in use.");
}
return;
}
recycleUnchecked();
}
//對(duì)于不再使用的消息撤摸，加入到消息池
void recycleUnchecked() {
//將消息標(biāo)示位置為IN_USE，并清空消息所有的參數(shù)褒纲。
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) { //當(dāng)消息池沒有滿時(shí)准夷，將Message對(duì)象加入消息池
next = sPool;
sPool = this;
sPoolSize++; //消息池的可用大小進(jìn)行加1操作
}
}
}
recycle()，將Message加入到消息池的過程莺掠，都是把Message加到鏈表的表頭衫嵌。
Handler工作原理
Handler的工作主要包含消息的發(fā)送和接收過程。消息發(fā)送可以通過post的一系列的方法以及send的一系列方法來實(shí)現(xiàn)彻秆，post其實(shí)也是通過send的方法來實(shí)現(xiàn)的楔绞。
看下Handler的構(gòu)造方法结闸。
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();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
從中可以看到關(guān)聯(lián)MessageQueue、Looper酒朵，所以在Handler之前Looper要prepare先桦锄，如果沒有Looper的話，就會(huì)拋出“Can't create handler inside thread that has not called Looper.prepare()”這句話蔫耽。
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
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);
}
public final boolean sendMessageAtFrontOfQueue(Message msg) {
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, 0);
}
從中可以看出结耀，最終都是調(diào)用sendMessageAtTime/sendMessageAtFrontOfQueue方法，進(jìn)而執(zhí)行enqueueMessage方法匙铡，最終把消息發(fā)送到MessageQueue隊(duì)列中饼记。
相關(guān)消息發(fā)送方式
那么消息又是如何在Handler處理的呢？
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
通過dispatchMessage來處理消息的慰枕。
ThreadLocal工作原理
ThreadLocal是一個(gè) 線程內(nèi)部的數(shù)據(jù)存儲(chǔ)類具则，通過它可以在指定的線程中存儲(chǔ)數(shù)據(jù)，數(shù)據(jù)存儲(chǔ)以后具帮，只有在指定線程中可以獲取到存儲(chǔ)的數(shù)據(jù)博肋，對(duì)于其他線程來說是無法獲取到數(shù)據(jù)。在日常開發(fā)中用到ThreadLocal的場(chǎng)景很少蜂厅，但是在某些特殊的場(chǎng)景下匪凡，通過ThreadLocal可以輕松地實(shí)現(xiàn)一些看起來很復(fù)雜的功能，這一點(diǎn)在Android源碼中也有所體現(xiàn)掘猿，比如Looper病游、ActivityThread以及AMS中都用到ThreadLocal。
ThreadLocal.set(T value)：將value存儲(chǔ)到當(dāng)前線程的TLS區(qū)域稠通。
public void set(T value) {
Thread currentThread = Thread.currentThread(); //獲取當(dāng)前線程
Values values = values(currentThread); //查找當(dāng)前線程的本地儲(chǔ)存區(qū)
if (values == null) {
//當(dāng)線程本地存儲(chǔ)區(qū)衬衬，尚未存儲(chǔ)該線程相關(guān)信息時(shí)，則創(chuàng)建Values對(duì)象
values = initializeValues(currentThread);
}
//保存數(shù)據(jù)value到當(dāng)前線程this
values.put(this, value);
}
在set方法中改橘，首先會(huì)通過values方法來獲取當(dāng)前線程的ThreadLocal數(shù)據(jù)滋尉，通過put方式去獲取。
ThreadLocal.get()：獲取當(dāng)前線程TLS區(qū)域的數(shù)據(jù)飞主。
public T get() {
Thread currentThread = Thread.currentThread(); //獲取當(dāng)前線程
Values values = values(currentThread); //查找當(dāng)前線程的本地儲(chǔ)存區(qū)
if (values != null) {
Object[] table = values.table;
int index = hash & values.mask;
if (this.reference == table[index]) {
return (T) table[index + 1]; //返回當(dāng)前線程儲(chǔ)存區(qū)中的數(shù)據(jù)
}
} else {
//創(chuàng)建Values對(duì)象
values = initializeValues(currentThread);
}
return (T) values.getAfterMiss(this); //從目標(biāo)線程存儲(chǔ)區(qū)沒有查詢是則返回null
}
get方法同樣是取出當(dāng)前線程的localValues對(duì)象狮惜，如果這個(gè)對(duì)象為null，那么就返回初始值碌识。
在Looper源碼中碾篡，有這么一句：
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
從ThreadLocal的set和get方法可以看出，它們所操作的對(duì)象都是當(dāng)前線程的localValues對(duì)象的table數(shù)組筏餐，因此在不同線程中訪問同一個(gè)ThreadLocal的set和get方法开泽，它們對(duì)ThreadLocal所做的讀/寫操作僅限于各自線程的內(nèi)部，這也就是為什么ThreadLocal可以在多個(gè)線程中互不干擾地存儲(chǔ)和修改數(shù)據(jù)胖烛。
所以眼姐，整體來說，Handler佩番、Looper众旗、MessageQueue、Message這三者之間的關(guān)系如下：
消息機(jī)制關(guān)系圖
主線程的消息循環(huán)
Android的主線程就是ActivityThread趟畏，主線程的入口方法在main贡歧，在main方法中系統(tǒng)會(huì)通過Looper.prepareMainLooper方法來創(chuàng)建主線程的Looper以及MessageQueue，并通過Looper.loop方法來開啟主線程的消息循環(huán)赋秀。
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
SamplingProfilerIntegration.start();
// CloseGuard defaults to true and can be quite spammy. We
// disable it here, but selectively enable it later (via
// StrictMode) on debug builds, but using DropBox, not logs.
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
// Set the reporter for event logging in libcore
EventLogger.setReporter(new EventLoggingReporter());
// Make sure TrustedCertificateStore looks in the right place for CA certificates
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
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");
}
主線程的消息循環(huán)開始以后利朵，ActivityThread還需要一個(gè)Handler來和消息隊(duì)列進(jìn)行交互，這個(gè)Handler就是ActivityThread.H猎莲，它內(nèi)部定義了一組消息類型绍弟，主要包括了四大組件的啟動(dòng)和停止等過程。
private class H extends Handler {
public static final int LAUNCH_ACTIVITY = 100;
public static final int PAUSE_ACTIVITY = 101;
public static final int PAUSE_ACTIVITY_FINISHING= 102;
public static final int STOP_ACTIVITY_SHOW = 103;
public static final int STOP_ACTIVITY_HIDE = 104;
public static final int SHOW_WINDOW = 105;
public static final int HIDE_WINDOW = 106;
public static final int RESUME_ACTIVITY = 107;
public static final int SEND_RESULT = 108;
public static final int DESTROY_ACTIVITY = 109;
public static final int BIND_APPLICATION = 110;
public static final int EXIT_APPLICATION = 111;
public static final int NEW_INTENT = 112;
public static final int RECEIVER = 113;
public static final int CREATE_SERVICE = 114;
public static final int SERVICE_ARGS = 115;
public static final int STOP_SERVICE = 116;
public static final int CONFIGURATION_CHANGED = 118;
public static final int CLEAN_UP_CONTEXT = 119;
public static final int GC_WHEN_IDLE = 120;
public static final int BIND_SERVICE = 121;
public static final int UNBIND_SERVICE = 122;
public static final int DUMP_SERVICE = 123;
public static final int LOW_MEMORY = 124;
public static final int ACTIVITY_CONFIGURATION_CHANGED = 125;
public static final int RELAUNCH_ACTIVITY = 126;
public static final int PROFILER_CONTROL = 127;
public static final int CREATE_BACKUP_AGENT = 128;
public static final int DESTROY_BACKUP_AGENT = 129;
public static final int SUICIDE = 130;
public static final int REMOVE_PROVIDER = 131;
public static final int ENABLE_JIT = 132;
public static final int DISPATCH_PACKAGE_BROADCAST = 133;
public static final int SCHEDULE_CRASH = 134;
public static final int DUMP_HEAP = 135;
public static final int DUMP_ACTIVITY = 136;
public static final int SLEEPING = 137;
public static final int SET_CORE_SETTINGS = 138;
public static final int UPDATE_PACKAGE_COMPATIBILITY_INFO = 139;
public static final int TRIM_MEMORY = 140;
public static final int DUMP_PROVIDER = 141;
public static final int UNSTABLE_PROVIDER_DIED = 142;
public static final int REQUEST_ASSIST_CONTEXT_EXTRAS = 143;
public static final int TRANSLUCENT_CONVERSION_COMPLETE = 144;
public static final int INSTALL_PROVIDER = 145;
public static final int ON_NEW_ACTIVITY_OPTIONS = 146;
public static final int CANCEL_VISIBLE_BEHIND = 147;
public static final int BACKGROUND_VISIBLE_BEHIND_CHANGED = 148;
public static final int ENTER_ANIMATION_COMPLETE = 149;
public static final int START_BINDER_TRACKING = 150;
public static final int STOP_BINDER_TRACKING_AND_DUMP = 151;
public static final int MULTI_WINDOW_MODE_CHANGED = 152;
public static final int PICTURE_IN_PICTURE_MODE_CHANGED = 153;
public static final int LOCAL_VOICE_INTERACTION_STARTED = 154;
String codeToString(int code) {
if (DEBUG_MESSAGES) {
switch (code) {
case LAUNCH_ACTIVITY: return "LAUNCH_ACTIVITY";
case PAUSE_ACTIVITY: return "PAUSE_ACTIVITY";
case PAUSE_ACTIVITY_FINISHING: return "PAUSE_ACTIVITY_FINISHING";
case STOP_ACTIVITY_SHOW: return "STOP_ACTIVITY_SHOW";
case STOP_ACTIVITY_HIDE: return "STOP_ACTIVITY_HIDE";
case SHOW_WINDOW: return "SHOW_WINDOW";
case HIDE_WINDOW: return "HIDE_WINDOW";
case RESUME_ACTIVITY: return "RESUME_ACTIVITY";
case SEND_RESULT: return "SEND_RESULT";
case DESTROY_ACTIVITY: return "DESTROY_ACTIVITY";
case BIND_APPLICATION: return "BIND_APPLICATION";
case EXIT_APPLICATION: return "EXIT_APPLICATION";
case NEW_INTENT: return "NEW_INTENT";
case RECEIVER: return "RECEIVER";
case CREATE_SERVICE: return "CREATE_SERVICE";
case SERVICE_ARGS: return "SERVICE_ARGS";
case STOP_SERVICE: return "STOP_SERVICE";
case CONFIGURATION_CHANGED: return "CONFIGURATION_CHANGED";
case CLEAN_UP_CONTEXT: return "CLEAN_UP_CONTEXT";
case GC_WHEN_IDLE: return "GC_WHEN_IDLE";
case BIND_SERVICE: return "BIND_SERVICE";
case UNBIND_SERVICE: return "UNBIND_SERVICE";
case DUMP_SERVICE: return "DUMP_SERVICE";
case LOW_MEMORY: return "LOW_MEMORY";
case ACTIVITY_CONFIGURATION_CHANGED: return "ACTIVITY_CONFIGURATION_CHANGED";
case RELAUNCH_ACTIVITY: return "RELAUNCH_ACTIVITY";
case PROFILER_CONTROL: return "PROFILER_CONTROL";
case CREATE_BACKUP_AGENT: return "CREATE_BACKUP_AGENT";
case DESTROY_BACKUP_AGENT: return "DESTROY_BACKUP_AGENT";
case SUICIDE: return "SUICIDE";
case REMOVE_PROVIDER: return "REMOVE_PROVIDER";
case ENABLE_JIT: return "ENABLE_JIT";
case DISPATCH_PACKAGE_BROADCAST: return "DISPATCH_PACKAGE_BROADCAST";
case SCHEDULE_CRASH: return "SCHEDULE_CRASH";
case DUMP_HEAP: return "DUMP_HEAP";
case DUMP_ACTIVITY: return "DUMP_ACTIVITY";
case SLEEPING: return "SLEEPING";
case SET_CORE_SETTINGS: return "SET_CORE_SETTINGS";
case UPDATE_PACKAGE_COMPATIBILITY_INFO: return "UPDATE_PACKAGE_COMPATIBILITY_INFO";
case TRIM_MEMORY: return "TRIM_MEMORY";
case DUMP_PROVIDER: return "DUMP_PROVIDER";
case UNSTABLE_PROVIDER_DIED: return "UNSTABLE_PROVIDER_DIED";
case REQUEST_ASSIST_CONTEXT_EXTRAS: return "REQUEST_ASSIST_CONTEXT_EXTRAS";
case TRANSLUCENT_CONVERSION_COMPLETE: return "TRANSLUCENT_CONVERSION_COMPLETE";
case INSTALL_PROVIDER: return "INSTALL_PROVIDER";
case ON_NEW_ACTIVITY_OPTIONS: return "ON_NEW_ACTIVITY_OPTIONS";
case CANCEL_VISIBLE_BEHIND: return "CANCEL_VISIBLE_BEHIND";
case BACKGROUND_VISIBLE_BEHIND_CHANGED: return "BACKGROUND_VISIBLE_BEHIND_CHANGED";
case ENTER_ANIMATION_COMPLETE: return "ENTER_ANIMATION_COMPLETE";
case MULTI_WINDOW_MODE_CHANGED: return "MULTI_WINDOW_MODE_CHANGED";
case PICTURE_IN_PICTURE_MODE_CHANGED: return "PICTURE_IN_PICTURE_MODE_CHANGED";
case LOCAL_VOICE_INTERACTION_STARTED: return "LOCAL_VOICE_INTERACTION_STARTED";
}
}
return Integer.toString(code);
}
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case RELAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
ActivityClientRecord r = (ActivityClientRecord)msg.obj;
handleRelaunchActivity(r);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case PAUSE_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
SomeArgs args = (SomeArgs) msg.obj;
handlePauseActivity((IBinder) args.arg1, false,
(args.argi1 & USER_LEAVING) != 0, args.argi2,
(args.argi1 & DONT_REPORT) != 0, args.argi3);
maybeSnapshot();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case PAUSE_ACTIVITY_FINISHING: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
SomeArgs args = (SomeArgs) msg.obj;
handlePauseActivity((IBinder) args.arg1, true, (args.argi1 & USER_LEAVING) != 0,
args.argi2, (args.argi1 & DONT_REPORT) != 0, args.argi3);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case STOP_ACTIVITY_SHOW: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
SomeArgs args = (SomeArgs) msg.obj;
handleStopActivity((IBinder) args.arg1, true, args.argi2, args.argi3);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case STOP_ACTIVITY_HIDE: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
SomeArgs args = (SomeArgs) msg.obj;
handleStopActivity((IBinder) args.arg1, false, args.argi2, args.argi3);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case SHOW_WINDOW:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityShowWindow");
handleWindowVisibility((IBinder)msg.obj, true);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case HIDE_WINDOW:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityHideWindow");
handleWindowVisibility((IBinder)msg.obj, false);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case RESUME_ACTIVITY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
SomeArgs args = (SomeArgs) msg.obj;
handleResumeActivity((IBinder) args.arg1, true, args.argi1 != 0, true,
args.argi3, "RESUME_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case SEND_RESULT:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
handleSendResult((ResultData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case DESTROY_ACTIVITY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
handleDestroyActivity((IBinder)msg.obj, msg.arg1 != 0,
msg.arg2, false);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case EXIT_APPLICATION:
if (mInitialApplication != null) {
mInitialApplication.onTerminate();
}
Looper.myLooper().quit();
break;
case NEW_INTENT:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");
handleNewIntent((NewIntentData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case RECEIVER:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
handleReceiver((ReceiverData)msg.obj);
maybeSnapshot();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
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;
case SERVICE_ARGS:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceStart: " + String.valueOf(msg.obj)));
handleServiceArgs((ServiceArgsData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case STOP_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop");
handleStopService((IBinder)msg.obj);
maybeSnapshot();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case CONFIGURATION_CHANGED:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "configChanged");
mCurDefaultDisplayDpi = ((Configuration)msg.obj).densityDpi;
mUpdatingSystemConfig = true;
handleConfigurationChanged((Configuration)msg.obj, null);
mUpdatingSystemConfig = false;
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case CLEAN_UP_CONTEXT:
ContextCleanupInfo cci = (ContextCleanupInfo)msg.obj;
cci.context.performFinalCleanup(cci.who, cci.what);
break;
case GC_WHEN_IDLE:
scheduleGcIdler();
break;
case DUMP_SERVICE:
handleDumpService((DumpComponentInfo)msg.obj);
break;
case LOW_MEMORY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "lowMemory");
handleLowMemory();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case ACTIVITY_CONFIGURATION_CHANGED:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityConfigChanged");
handleActivityConfigurationChanged((ActivityConfigChangeData) msg.obj,
msg.arg1 == 1 ? REPORT_TO_ACTIVITY : !REPORT_TO_ACTIVITY);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case PROFILER_CONTROL:
handleProfilerControl(msg.arg1 != 0, (ProfilerInfo)msg.obj, msg.arg2);
break;
case CREATE_BACKUP_AGENT:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupCreateAgent");
handleCreateBackupAgent((CreateBackupAgentData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case DESTROY_BACKUP_AGENT:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupDestroyAgent");
handleDestroyBackupAgent((CreateBackupAgentData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case SUICIDE:
Process.killProcess(Process.myPid());
break;
case REMOVE_PROVIDER:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "providerRemove");
completeRemoveProvider((ProviderRefCount)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case ENABLE_JIT:
ensureJitEnabled();
break;
case DISPATCH_PACKAGE_BROADCAST:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastPackage");
handleDispatchPackageBroadcast(msg.arg1, (String[])msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case SCHEDULE_CRASH:
throw new RemoteServiceException((String)msg.obj);
case DUMP_HEAP:
handleDumpHeap(msg.arg1 != 0, (DumpHeapData)msg.obj);
break;
case DUMP_ACTIVITY:
handleDumpActivity((DumpComponentInfo)msg.obj);
break;
case DUMP_PROVIDER:
handleDumpProvider((DumpComponentInfo)msg.obj);
break;
case SLEEPING:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "sleeping");
handleSleeping((IBinder)msg.obj, msg.arg1 != 0);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case SET_CORE_SETTINGS:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setCoreSettings");
handleSetCoreSettings((Bundle) msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case UPDATE_PACKAGE_COMPATIBILITY_INFO:
handleUpdatePackageCompatibilityInfo((UpdateCompatibilityData)msg.obj);
break;
case TRIM_MEMORY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "trimMemory");
handleTrimMemory(msg.arg1);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case UNSTABLE_PROVIDER_DIED:
handleUnstableProviderDied((IBinder)msg.obj, false);
break;
case REQUEST_ASSIST_CONTEXT_EXTRAS:
handleRequestAssistContextExtras((RequestAssistContextExtras)msg.obj);
break;
case TRANSLUCENT_CONVERSION_COMPLETE:
handleTranslucentConversionComplete((IBinder)msg.obj, msg.arg1 == 1);
break;
case INSTALL_PROVIDER:
handleInstallProvider((ProviderInfo) msg.obj);
break;
case ON_NEW_ACTIVITY_OPTIONS:
Pair<IBinder, ActivityOptions> pair = (Pair<IBinder, ActivityOptions>) msg.obj;
onNewActivityOptions(pair.first, pair.second);
break;
case CANCEL_VISIBLE_BEHIND:
handleCancelVisibleBehind((IBinder) msg.obj);
break;
case BACKGROUND_VISIBLE_BEHIND_CHANGED:
handleOnBackgroundVisibleBehindChanged((IBinder) msg.obj, msg.arg1 > 0);
break;
case ENTER_ANIMATION_COMPLETE:
handleEnterAnimationComplete((IBinder) msg.obj);
break;
case START_BINDER_TRACKING:
handleStartBinderTracking();
break;
case STOP_BINDER_TRACKING_AND_DUMP:
handleStopBinderTrackingAndDump((ParcelFileDescriptor) msg.obj);
break;
case MULTI_WINDOW_MODE_CHANGED:
handleMultiWindowModeChanged((IBinder) msg.obj, msg.arg1 == 1);
break;
case PICTURE_IN_PICTURE_MODE_CHANGED:
handlePictureInPictureModeChanged((IBinder) msg.obj, msg.arg1 == 1);
break;
case LOCAL_VOICE_INTERACTION_STARTED:
handleLocalVoiceInteractionStarted((IBinder) ((SomeArgs) msg.obj).arg1,
(IVoiceInteractor) ((SomeArgs) msg.obj).arg2);
break;
}
Object obj = msg.obj;
if (obj instanceof SomeArgs) {
((SomeArgs) obj).recycle();
}
if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
}
ActivityThread通過ApplicationThread和AMS進(jìn)行進(jìn)程間通信著洼，AMS以進(jìn)程間通信的方式完成ActivityThread的請(qǐng)求回調(diào)ApplicationThread中Binder方法然后ApplicationThread向H發(fā)送消息樟遣，H收到消息后會(huì)將ApplicationThread的邏輯切換到ActivityThread中去執(zhí)行，即切換到主線程中去執(zhí)行身笤，整個(gè)過程就是主線程的消息循環(huán)模型豹悬。
HandlerThread
HandlerThread類的源碼：
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
protected void onLooperPrepared() {
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
/**
* Returns the identifier of this thread. See Process.myTid().
*/
public int getThreadId() {
return mTid;
}
}
可以看到HandlerThread繼承于Thread類，在獲取Looper對(duì)象時(shí)候液荸，當(dāng)線程已經(jīng)啟動(dòng)瞻佛，則等待直到looper創(chuàng)建完成才能獲取，從本質(zhì)上看HandlerThread是對(duì)Thread的封裝娇钱，主要用途在于多個(gè)線程的通信伤柄，會(huì)有同步的問題，那么Android對(duì)此直接提供了HandlerThread類文搂。
HandlerThread實(shí)戰(zhàn)
在HandlerThread線程中運(yùn)行Loop()方法响迂，在其他線程中通過Handler發(fā)送消息到HandlerThread線程。通過wait/notifyAll的方式细疚，有效地解決了多線程的同步問題蔗彤。從源碼中我們也可以看到當(dāng)looper沒獲取成功就會(huì)阻塞，然后有運(yùn)行完就會(huì)去喚醒所有阻塞的線程疯兼。
// Step 1: 創(chuàng)建并啟動(dòng)HandlerThread線程然遏，內(nèi)部包含Looper
HandlerThread handlerThread = new HandlerThread("test");
handlerThread.start();
// Step 2: 創(chuàng)建Handler
Handler handler = new Handler(handlerThread.getLooper());
// Step 3: 發(fā)送消息
handler.post(new Runnable() {
@Override
public void run() {
System.out.println("thread id="+Thread.currentThread().getId());
}
});
