個人所有文章整理在此篇，將陸續更新收錄:知無涯，行者之路莫言終（我的程式設計之路）
前言
哥發誓，這是我最後一次分析Handler(這是我第三次說這句話，希望不會有下次了)
說起Handler新手的小噩夢,用起來不難，理解起來煩神
Handler總覽
一、引入Handler的一般套路
1.說Handler一般套路是從一個異常開始
你以為我會這麼俗氣地從：
非主執行緒禁止更新UI開始說Handler嗎?--是的
這個異常定義在ViewRootImpl裡,更新TextView的UI為什麼ViewRootImpl報異常?
子不教，父之過，教不嚴，師之惰唄。在framework的原始碼裡看一下吧，
---->[ViewRootImpl#checkThread]-------
void checkThread() {
if (mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
}
|--可見在checkThread時會判斷mThread是不是等於當前執行緒，如果不等於，就異常
|---那mThread又是什麼執行緒呢?
---->[ViewRootImpl#ViewRootImpl]-------
public ViewRootImpl(Context context, Display display) {
mThread = Thread.currentThread();
|--在構造方法中被賦值的，也就是說是建立ViewRootImpl時所在的執行緒
|---ViewRootImpl又是在哪裡被建立的呢?這裡不深入講了，是在main執行緒
|---從異常來看是在進行requestLayout方法時崩的
---->[ViewRootImpl#requestLayout]-------
@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
scheduleTraversals();
}
}
複製程式碼2.然後再俗套的說一下怎麼用Handler解決
然後發現Handler好神奇啊，至於那裡神奇也說不出個道道，也就是神祕
Handler的面具之下隱藏著一個有點小複雜的訊息機制，這篇就來理一下
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
msgTv.setText("hello");
}
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v->{
new Thread(new Runnable() {
@Override
public void run() {
mHandler.sendEmptyMessage(0x01);
}
}).start();
});
}
}
複製程式碼3.原始碼中對Handler的描述
自己翻譯的，僅供參考，有不恰之處敬請指出
其中提到了MessageQueue和message以及runnables
|--Handler允許您傳送和處理與執行緒的MessageQueue關聯的訊息和可執行物件。
|--每個Handler例項都與單個執行緒和該執行緒的訊息佇列相關聯。
|--當您建立一個新的Handler時，它會被繫結到正在建立它的執行緒的執行緒/訊息佇列上，
|--從那時起，它將向該訊息佇列傳遞訊息和可執行項，並在它們從訊息佇列發出時執行它們。
|--Handler有兩大主要的用處：
|--(1) 安排將訊息和可執行項在將來的某個點執行
|--(2) 將在不同執行緒上執行的操作加入佇列。
|--排程訊息是通過方法：
|--post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long),
|--sendEmptyMessage(int), sendMessage(Message),sendMessageAtTime(Message, long),
|--sendMessageDelayed(Message, long).
複製程式碼4.主要成員變數
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;
複製程式碼5.構造方法
看這七個葫蘆娃，核心就只有兩個構造方法(三個hide的，外面不能用)，其他四個可以用
|--對具有指定回撥介面的[當前執行緒]使用Looper，並設定handler是否應該是非同步的。
|--預設情況下，handler是同步的，除非使用此建構函式建立一個嚴格非同步的handler。
|--(插句話，此方法是隱藏的，說明外部呼叫者是無法建立非同步的handler)
|--非同步訊息表示：不需要對同步訊息進行全域性排序的中斷或事件。
|--非同步訊息不受MessageQueue#enqueueSyncBarrier(long)引入的同步屏障的限制。
* @param callback 處理訊息的回撥介面，或null。
* @param async 如果為true，handler將為[傳送到它那的每個Message或Runnable]呼叫
* Message#setAsynchronous(boolean)
---->[Handler#Handler(Callback,boolean)]-------------------------------
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {//final常量---false，所以不管他
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();//通過Looper的myLooper方法返回值，為mLooper賦值
if (mLooper == null) {//如果mLooper拿不到，報異常
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;//mQueue通過mLooper獲取
mCallback = callback;//入參
mAsynchronous = async;//入參
}
|--貌似也沒有做什麼東西，只是將mLooper、mQueue、mCallback、mAsynchronous賦值
|--焦點在Looper.myLooper()上
---->[Handler#Handler(Callback,boolean)]-------------------------------
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
|--三參的大佬挺任性，直接賦值，所以Handler的建構函式沒有什麼太特別的
|--下面看一下Looper類
複製程式碼二、赤膽忠心:Looper
1:ThreadLocal
花了點時間看了ThreadLocal，已單獨成文，詳情見:
java點將臺：多重影分身[-ThreadLocal-]
這裡不過多探討ThreadLocal，給個小例子，看它的功能
public class ThreadLocalTest {
//例項化一個裝載Integer型別的ThreadLocal靜態變數
static final ThreadLocal<Integer> sThreadLocal = new ThreadLocal<>();
//用來測試的共享成員變數
static int count = 10;
public static void main(String[] args) throws InterruptedException {
sThreadLocal.set(count);
Thread thread = new Thread() {
@Override
public void run() {//新建執行緒
count++;
sThreadLocal.set(count);
System.out.println("new :" + sThreadLocal.get());
}
};
thread.start();
thread.join();//為避免歧義，這裡新執行緒join,讓main執行緒的列印在新執行緒執行之後
System.out.println("main:"+sThreadLocal.get());
}
}
複製程式碼可以看出，在新執行緒中對sThreadLocal.set(),並不會影響main執行緒的get()
所以共享成員變數count放在sThreadLocal這個籃子裡，可以保證執行緒間共享變數的獨立
2.Looper類(looper:/'luːpə/ 迴圈者)
類名:Looper 父類:Object 修飾:public final
實現的介面:[]
包名:android.os 依賴類個數:7
內部類/介面個數：0
原始碼行數：344 原始碼行數(除註釋):158
屬性個數：8 方法個數:20 public方法個數:18
複製程式碼---->[Looper#成員變數]------------
//例項化一個裝載Looper型別的ThreadLocal靜態變數
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//似有靜態內部成員變數sMainLooper
private static Looper sMainLooper;
//MessageQueue物件
final MessageQueue mQueue;
//執行緒物件
final Thread mThread;
---->[Looper#Looper]------------
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
|--在Looper的建構函式中，分別對mQueue，mThread進行初始化
|--注意建構函式是私有的，所以無法直接構造Looper物件
複製程式碼所以本類中一定存在
new Looper,搜尋一下:
//公共靜態方法：準備
---->[Looper#prepare]------------
public static void prepare() {
prepare(true);
}
//私有靜態方法：準備
---->[Looper#prepare(boolean)]------------
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
//如果sThreadLocal可與獲取到Looper,拋異常
//也就是一個執行緒只能夠建立一個Looper
throw new RuntimeException("Only one Looper may be created per thread");
}
//為空時建立Looper物件，並以sThreadLocal為鍵，new Looper(quitAllowed)為值
//設定到當前執行緒的threadLocals(ThreadLocalMap物件)上
sThreadLocal.set(new Looper(quitAllowed));
}
---->[Looper#prepare(boolean)]------------
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
|--Looper會在因ThreadLocal在每個執行緒中獨立，非Looper生成的執行緒
|--sThreadLocal.get()會得到null,那prepare()是framework層的那裡初始化(即prepare)的呢?
複製程式碼3.ActivityThread中對Looper的初始化
到framework層的原始碼去看一下，程式的入口main方法在ActivityThread中
---->[ActivityThread#成員變數]---------
final Looper mLooper = Looper.myLooper();
---->[ActivityThread#main]---------
public static void main(String[] args) {
//略...
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();//開啟loop
throw new RuntimeException("Main thread loop unexpectedly exited");
---->[Looper#prepareMainLooper]---------
public static void prepareMainLooper() {
//這裡呼叫了prepare方法，為sThreadLocal設定了Looper值
而且在main函式中呼叫，所線上程為main執行緒，即主執行緒
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {//這裡看出只能prepared一次
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();//在這裡初始化成員變數sMainLooper
}
}
複製程式碼在這裡為了方便說明，debug來測試一下：
在main執行緒和子執行緒分別進行斷點除錯，看一下兩個執行緒中的Looper.myLooper()
由於Looper.prepare在main執行緒中執行，即：sThreadLocal.set在main執行緒
所以Looper.myLooper()，即sThreadLocal.get()在子執行緒無法獲取到Looper，這就是ThreadLocal的作用
三、再看Handler
1.使用含Callback的建構函式
以前是直接在Handler中覆寫
handleMessage方法，AndroidStudio飄橙色，看起來很礙眼
我們完全可以傳回撥來構建Handler，加上Java8的簡化書寫看著爽多了，執行無誤
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler ;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mHandler = new Handler(msg -> {
msgTv.setText("hello");
return true;
});
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v->{
Thread thread = new Thread(() ->
mHandler.sendEmptyMessage(0x01));
thread.start();
});
}
}
複製程式碼2.看一下CallBack介面
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
在例項化處理程式時可以使用回撥介面，以避免必須實現自己的處理Handler子類。
*/
---->[Handler$Callback]----------------------
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True 如果不需要進一步處理
*/
public boolean handleMessage(Message msg);
}
/**
* Handle system messages here.(在這裡處理系統訊息)
*/
---->[Handler#dispatchMessage]----------------------
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {//如果mCallback不為空
//先回撥用 mCallback.handleMessage(msg)，返回true的話,之後就return了
//這有什麼用? 如果你重寫Handler的handleMessage又有Callback都有的話
// true就不會再去執行Handler的handleMessage 的方法了,例子如下
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
複製程式碼3.即使用Callback又覆寫handleMessage
感覺很不是很常用，瞭解一下即可，
下面程式碼return true;結果是hello,return false;結果是hello2
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mHandler = new Handler(msg -> {
msgTv.setText("hello");
return true;
}) {
@Override
public void handleMessage(Message msg) {
msgTv.setText("hello2");
}
};
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
mHandler.sendEmptyMessage(0x01);
});
thread.start();
});
}
}
複製程式碼4.在子執行緒中建立Handler物件是否有用?
現在將建立Handler放在子執行緒進行,不出所料，崩了
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Handler.Callback callback = msg -> {
msgTv.setText("hello");
return true;
};
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
mHandler = new Handler(callback);//<--建立Handler
mHandler.sendEmptyMessage(0x01);
});
thread.start();
});
}
}
---->[看一下崩的原因]----------------
---->[Handler#Handler(Callback, boolean)]----------------
public Handler(Callback callback, boolean async) {
//略...
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;
}
|---前面我們已經debug過，在子執行緒中Looper.myLooper()為空，所以會崩掉
複製程式碼5.如何在子執行緒中建立Handler
Handler的建構函式中有Looper引數，我們可以在外面獲取主執行緒的Looper物件，給Handler構造
除此之外Context也給我們提供了獲取main執行緒Looper的方法，debug可以看出，兩者是同一物件
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Handler.Callback callback = msg -> {
msgTv.setText("hello");
return true;
};
Looper looper = Looper.myLooper();//獲取main執行緒的looper
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
mHandler = new Handler(looper,callback);
mHandler.sendEmptyMessage(0x01);
});
thread.start();
});
}
}
複製程式碼四、訊息佇列(難點，核心)
1.回到這個最簡單的訊息傳送
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Handler.Callback callback = msg -> {
msgTv.setText("hello");
return true;
};
mHandler = new Handler(callback);
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
mHandler.sendEmptyMessage(0x01);
});
thread.start();
});
}
}
複製程式碼2.走一下Handler原始碼
一連串的
sendMessageXXX基本上把傳送訊息的方法走了一遍，
但萬劍歸一，最終呼叫的是enqueueMessage(MessageQueue queue,Message msg, long uptimeMillis)
sendEmptyMessage(int what) : 傳送空訊息，
sendEmptyMessageDelayed(int what, long delayMillis)，傳送延遲空訊息
sendMessageDelayed(Message msg, long delayMillis) 傳送延遲訊息
sendMessageAtTime(Message msg, long uptimeMillis) 定時傳送訊息
enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) 訊息入隊
複製程式碼---->[Handler#sendEmptyMessage]-----------------
|--只有訊息的what(用來表識訊息),呼叫：sendEmptyMessageDelayed
public final boolean sendEmptyMessage(int what){
return sendEmptyMessageDelayed(what, 0);
}
---->[Handler#sendEmptyMessageDelayed]-----------------
|--只有訊息的what(用來表識訊息),延遲毫秒數，呼叫：sendMessageDelayed
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
---->[Handler#sendMessageDelayed]-----------------
|--接收一個訊息物件，延遲毫秒數，呼叫 sendMessageAtTime
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
---->[Handler#sendMessageAtTime]-----------------
|--接收一個訊息物件，延遲毫秒數，呼叫 enqueueMessage
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);
}
---->[Handler#enqueueMessage]-----------------
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//注意這裡講當前Handler作為訊息的target
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);//呼叫了MessageQueue的enqueueMessage方法
}
複製程式碼現在我們面前出現了兩個類：
Message和MessageQueue
3.先看Message(訊息)類
Message的成員變數有點多
what----int 型，用來表識該資訊
arg1----int型，儲存簡單的int資料
arg2----int型，儲存簡單的int資料
obj --- 任意型別，儲存任意資料
replyTo ---- Messenger型別 可選的信使，在那裡回覆這條訊息可以傳送。具體如何使用它的語義取決於傳送方和接收方。
複製程式碼先從一個例子開始引入Message吧
3.1：new Message()與Message.obtain()與Handler.obtain()
可見三種方式都能運作，那麼有什麼區別呢?
/**
* 作者：張風捷特烈<br/>
* 時間：2019/1/25/025:14:24<br/>
* 郵箱：1981462002@qq.com<br/>
* 說明：三種建立訊息物件的方式
*/
public class HandlerActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Handler.Callback callback = msg -> {
String txt = (String) msg.obj;
switch (msg.what) {
case 0x01:
txt += "----第一條";
break;
case 0x02:
txt += "----第二條";
break;
case 0x03:
txt += "----第三條";
break;
}
msgTv.setText(txt);
return true;
};
mHandler = new Handler(callback);
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
//new Message()建立訊息
Message newMsg = new Message();
newMsg.what = 0x01;
newMsg.obj = "玉面奕星龍";
mHandler.sendMessage(newMsg);
//Message.obtain()建立訊息
Message msgObtain = Message.obtain();
msgObtain.what = 0x02;
msgObtain.obj = "張風捷特烈";
mHandler.sendMessageDelayed(msgObtain, 3000);
//mHandler.obtainMessage()建立訊息
Message handlerObtain = mHandler.obtainMessage();
handlerObtain.what = 0x03;
handlerObtain.obj = "千里巫纓";
mHandler.sendMessageDelayed(handlerObtain, 6000);
});
thread.start();
});
}
}
複製程式碼3.2：三者的區別
1. new Message() 直接建立物件，沒什麼好說的
2.---->[Message]------------------
private static final Object sPoolSync = new Object();//鎖物件
private static Message sPool;//訊息池的連結串列首
private static int sPoolSize = 0;//當前訊息池的大小
private static final int MAX_POOL_SIZE = 50;//訊息池的最大尺寸
---->[Message#obtain]------------------
public static Message obtain() {
synchronized (sPoolSync) {//同步鎖
if (sPool != null) {//如果訊息池不為空
Message m = sPool;//將sPool物件賦值給m物件
sPool = m.next;//m的next賦值給sPool物件
m.next = null;//將m的next置空
m.flags = 0; // clear in-use flag
sPoolSize--;//訊息池的大小-1
return m;//將訊息返回
}
}
return new Message();//如果訊息池為空時，返回新的Message物件
}
|-- 這裡很明顯使用了單連結串列，將一個訊息從訊息池中出列。
|-- 維護訊息池的好處不用多說，避免頻繁建立和銷燬Message,
|-- 比如頻繁地傳送訊息(輪播圖),每次切換一下發一個訊息，使用訊息池維護會更好
3.---->[Handler#obtainMessage]------------------
public final Message obtainMessage(){
return Message.obtain(this);
}
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;
return m;
}
|-- 獲取Message後將target設定成當前handler,這一步enqueueMessage中已經有了，所以兩者一樣
|-- 除此之外Message還有很多過載的 `Message obtain`,都是基於Message.obtain，
|-- 同時再為其設定一些屬性，本質上也沒有什麼太大的區別，自己看一下就行了
複製程式碼4.MessageQueue訊息佇列
Message中並沒有為訊息池中新增訊息的方法，那麼訊息池是怎麼實現的?
從Handler#enqueueMessage為切入點，看一下這個訊息是如何加入訊息佇列中的
---->[Handler#enqueueMessage]------------------------
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//設定當前訊息的target為本Handler
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
---->[MessageQueue#enqueueMessage]------------------------
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {//target為null,即沒有對應的Handler，拋異常
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {//訊息已經在使用，拋異常
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {//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;//將mMessages,即隊首賦給p
boolean needWake;
if (p == null || when == 0 || when < p.when) {//p為空
//新建佇列頭，如果阻塞，喚醒事件佇列
msg.next = p;//當前訊息作為佇列首
mMessages = msg;//維護隊首
needWake = mBlocked;
} else {//表示當前訊息佇列中有訊息了
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;//宣告前一個訊息
for (;;) {//相當於while(true)的作用
prev = p;//將原來的隊首元素賦給prev變數
p = p.next;//將p的下一個訊息賦值給p
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; //將當前訊息的下一指向到p
prev.next = msg;//prev指向當前訊息
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
>看文字估計挺暈的，以上面三個訊息為例，分析一下他們加入的流程
複製程式碼當第二條訊息入隊時：msg：張風捷特烈
Message p = mMessages p:玉面奕星龍 不為空，走下面
Message prev;//宣告前一個訊息
for (;;) {//相當於while(true)的作用
prev = p;//prev：玉面奕星龍
p = p.next;//p.next =null,執行後 p=null
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; //張風捷特烈-->null
prev.next = msg;//玉面奕星龍-->張風捷特烈-->null
當第三條訊息入隊時：msg：百里巫纓
Message p = mMessages p:玉面奕星龍 不為空，走下面
Message prev;//宣告前一個訊息
for (;;) {//相當於while(true)的作用
//第一次迴圈--prev：玉面奕星龍
//第二次迴圈--prev：張風捷特烈
prev = p;
//第一次迴圈--p.next = 張風捷特烈,執行後 p=張風捷特烈
//第二次迴圈--p.next = null,執行後 p=null
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; //百里巫纓-->null,此時prev：張風捷特烈
prev.next = msg;//玉面奕星龍-->張風捷特烈-->百里巫纓-->null
|-- 由此可見，每新增一條訊息都是新增到隊尾
複製程式碼5.Looper的loop方法
將訊息加入佇列之後是如何取出的?又如何觸發Handler的dispatchMessage回撥方法?
這裡略去了打日誌的一些語句，可見loop方法一直將呼叫queue.next()直到msg == null
在拿到訊息後出發msg.target.dispatchMessage(msg);然後就豁然開朗了
但當沒有訊息時MessageQueue#next()會被阻塞,而導致loop阻塞。所以next無法讓輪循停止
要關閉迴圈使用MessageQueue#quit。
---->[Looper#loop]---------
public static void loop() {
//獲取當前執行緒的Looper物件
final Looper me = myLooper();
if (me == null) {//如果為空，報異常。說明當前執行緒沒有Looper物件
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.")
}
//queue使用的是Looper中的mQueue(在建構函式中被初始化)
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {//相當於while(true)的作用
Message msg = queue.next(); // 訊息
if (msg == null) {
return;
}
//略...
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
//略...
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
//在這裡呼叫了msg.target即該handler的dispatchMessage方法
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
//略...
msg.recycleUnchecked();
}
}
---->[MessageQueue#next]---------------
Message next() {
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1;
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);//這裡用來一個native方法
synchronized (this) {
//嘗試檢索下一條訊息。如果發現返回。
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;//前一個msg
Message msg = mMessages;//當前msg為隊首
if (msg != null && msg.target == null) {//一般都有target
// 被障礙物擋住了。在佇列中查詢下一個非同步訊息
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, Integ
} else {
//獲取一個msg-------
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 {
// 沒有訊息了
nextPollTimeoutMillis = -1;
}
// 現在所有掛起的訊息都已完成，請處理退出訊息
if (mQuitting) {
dispose();
return null;
}
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(pendingIdleHandl
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the hand
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 delivere
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}
---->[Handler#dispatchMessage]---------------
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//如果msg有回撥
handleCallback(msg);//處理msg的callback
} else {
if (mCallback != null) {//這個上面舉例說明過，不說了
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//回撥覆寫的handleMessage方法
}
}
---->[Handler#handleCallback]---------------
private static void handleCallback(Message message) {
message.callback.run();
}
複製程式碼關於MessageQueue#next方法，無非就是讓訊息出隊，沒有訊息時next會一直阻塞
這裡涉及了native的方法，以及控制next的阻塞來完成延遲觸發，這裡native不展開，
想深入的，這裡推薦一篇文章Android MessageQueue訊息迴圈處理機制
五、Handler#postXXX與Message的callback
1.dispatchMessage方法分析
不知道你有沒有注意到，msg裡有的callback,為了強調dispatchMessage，這裡再看一次
---->[Handler#dispatchMessage]---------------
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//如果msg有回撥
handleCallback(msg);//處理msg的callback
} else {
if (mCallback != null) {//這個上面舉例說明過，不說了
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//回撥覆寫的handleMessage方法
}
}
---->[Handler#handleCallback]---------------
private static void handleCallback(Message message) {
message.callback.run();
}
複製程式碼2.既然msg可以新增一個Runnable的callback那試一下唄
不幸的事callback是包訪問級別的，沒有提供set方法，所以用不了
但是提供了一個obtain的過載，可以放置callback
---->[Message#obtain(Handler, Runnable)]
public static Message obtain(Handler h, Runnable callback) {
Message m = obtain();
m.target = h;
m.callback = callback;
return m;
}
------------------------------------------------------
/**
* 作者：張風捷特烈<br/>
* 時間：2019/1/25/025:14:24<br/>
* 郵箱：1981462002@qq.com<br/>
* 說明：當msg自身有Runnable回撥時
*/
public class HandlerMsgWithCbkActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Handler.Callback callback = msg -> {
msgTv.setText("回撥的handleMessage");
return true;
};
mHandler = new Handler(callback){
@Override
public void handleMessage(Message msg) {
msgTv.setText("覆寫的handleMessage");
}
};
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
Message msgObtain = Message.obtain(mHandler, new Runnable() {
@Override
public void run() {
msgTv.setText("Message + Runnable");
}
});
msgObtain.what = 0x02;
msgObtain.obj = "張風捷特烈";
mHandler.sendMessageDelayed(msgObtain, 3000);
});
thread.start();
});
}
}
|--執行結果如下，結合dispatchMessage方法分析圖，應該足以說明
複製程式碼3.Handler的幾個postXXX方法
boolean post(Runnable r) post一個Runnable
boolean postAtTime(Runnable r, long uptimeMillis) 定時
boolean postAtTime(Runnable r, Object token, long uptimeMillis) 加token
boolean postDelayed(Runnable r, long delayMillis) 演示
boolean postAtFrontOfQueue(Runnable r) post到隊首
---->[Handler#post]-----------------
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
---->[Handler#getPostMessage]-----------------
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
|-- 可見post也沒有多麼高大上，只是呼叫了sendMessageDelayed而已
|-- 其中的Message通過getPostMessage獲取，在getPostMessage中
|-- 通過Message.obtain()從訊息池中取出一個訊息，並新增callback而已
|-- 後面幾個方法差不多，只是給Message多添一點資訊而已，Message理解了，就不成問題
|-- 這幾個方法相當於Handler給我們封裝了一下，要完成上面的測試，可以:
---->[HandlerMsgWithCbkActivity]-----------------
msgTv.setOnClickListener(v -> {
Thread thread = new Thread(() -> {
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
msgTv.setText("Message + Runnable");
}
}, 3000);
});
thread.start();
});
|-- 注意，使用postXXX,會讓Handler.callback和覆寫的handleMessage失效
|-- 因為其本質上是通過Message的callback，前面已經講了Message.callback一旦存在
|-- 是不會再走上兩者的。
複製程式碼終曲、回看Handler：
這時候回頭看一下Handler背後的訊息機制：
訊息承載單體：Message
訊息管理器：MessageQueue
訊息機制驅動力：Looper
訊息處理器：Handler
---->[為了結尾點題，編個故事吧]---注：本故事純屬虛構-------------
傳說在100億年前，宇宙不止一個，人們生活的宇宙被稱為main宇宙
除了main宇宙之外，稱為子宇宙，由於宇宙眾多，被人們稱為三千宇宙
有些人試圖在子宇宙改變自己的樣子(包括服飾)，開始新的生活，
但無一例外，全部灰飛煙滅，非main宇宙無法改變容飾成了平行宇宙法則
但main宇宙中人員眾多，資源相對匱乏，很多人只能去子宇宙去獲取資源
一個叫TextView的女生想要一件漂亮的衣服，作為男友的Handler義無反顧獨闖子宇宙，
他爆出了3件非常漂亮的衣服，知道讓TextView直接來到子宇宙穿上的話，她便會立刻灰飛煙滅
於是他用3個空間立方(Message)將3件衣服分別裝入其中，並標識message的target是自己
然後3個空間立方被依次放入了[平行宇宙傳送臺(MessageQueue)]，
main宇宙中的強大Looper能源驅動著[平行宇宙傳送臺],自從三千宇宙誕生的那刻就開啟了(Looper.loop)
當空間立方傳遞到主宇宙時，空間立方傳根據target找到自己的主人曾經的囑託(handleMessage)
然後將三件美麗的服飾依次給TextView穿上，這樣就實現了子宇宙資源對宇宙的傳送
有些常年在子宇宙工作的人，也經常使用這種機制，寄一封回家，傳達思念與祝福
而這些，就是當時他們的日常生活...
複製程式碼最後一個問題:Handler只是能在主宇宙和子宇宙間傳遞資源嗎?
每個子宇宙都可以擁有僅屬於自己的
一個Looper,子宇宙間也可以通過Handler進行通訊
/**
* 作者：張風捷特烈<br/>
* 時間：2019/1/25/025:14:24<br/>
* 郵箱：1981462002@qq.com<br/>
* 說明：子執行緒間通訊
*/
public class HandlerOtherActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
new Thread("第一子宇宙") {//第一子宇宙
@Override
public void run() {
Message newMsg = new Message();
newMsg.what = 0x01;
newMsg.obj = "玉面奕星龍";
mHandler.sendMessage(newMsg);
Log.e("HandlerOtherActivity", "當前執行緒名稱: " + Thread.currentThread().getName() + " 傳送：" + ne
}
}.start();
});
new Thread("第二子宇宙") {//第二子宇宙
@Override
public void run() {
Looper.prepare();//讓當前子宇宙生成--looper能源
//Handler通過第二子宇宙的looper能源能源構造
mHandler = new Handler(msg -> {
Log.e("HandlerOtherActivity", "當前執行緒名稱: " + Thread.currentThread().getName() + " 接收：" + ms
return false;
});
Log.e("HandlerOtherActivity", "run: ");
Looper.loop();//looper能源啟動--此時該執行緒會阻塞------下面的方法無法執行
Log.e("HandlerOtherActivity", "run:-------- ");
}
}.start();
}
}
|-- 注意點：當第一執行緒要向第二執行緒傳遞資料，mHandler要擁有第二執行緒的looper
|-- 也就是讓Handler在第二執行緒中建立，下圖已經很明確讓的表達出：
|-- 第一執行緒向第二執行緒傳遞了一條資訊,而且第二執行緒會阻塞在Looper.loop()是，下一句無法列印
複製程式碼為了讓你對Looper有更深的認識，換一種寫法
下面的寫法如果你看懂了,handler機制就不在話下了
一句話:在main執行緒中使用執行緒2的looper建立Handler，線上程1中通過Handler傳送訊息
結果訊息仍是線上程2中執行的，看日誌並未改變:(只有looper在哪個執行緒，訊息就會發到哪個執行緒)
/**
* 作者：張風捷特烈<br/>
* 時間：2019/1/25/025:14:24<br/>
* 郵箱：1981462002@qq.com<br/>
* 說明：子執行緒間通訊
*/
public class HandlerOtherActivity extends AppCompatActivity {
private TextView msgTv;
private Handler mHandler;
private Looper mOtherLooper;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ac_handler);
msgTv = findViewById(R.id.id_tv_handler);
msgTv.setOnClickListener(v -> {
new Thread("第一子宇宙") {//第一子宇宙
@Override
public void run() {
Message newMsg = new Message();
newMsg.what = 0x01;
newMsg.obj = "玉面奕星龍";
mHandler.sendMessage(newMsg);
Log.e("HandlerOtherActivity", "當前執行緒名稱: " + Thread.currentThread().getName() + " 傳送：" + newMsg.obj);
}
}.start();
});
new Thread("第二子宇宙") {//第二子宇宙
@Override
public void run() {
Looper.prepare();//讓當前子宇宙生成--looper能源
mOtherLooper = Looper.myLooper();
Log.e("HandlerOtherActivity", "run: ");
Looper.loop();//looper能源啟動--此時該執行緒會阻塞------下面的方法無法執行
Log.e("HandlerOtherActivity", "run:-------- ");
}
}.start();
try {
Thread.sleep(10);//睡10ms讓mOtherLooper可以初始化
// Handler通過第二子宇宙的looper能源能源構造
mHandler = new Handler(mOtherLooper, msg -> {
Log.e("HandlerOtherActivity", "當前執行緒名稱: " + Thread.currentThread().getName() + " 接收：" + msg.obj);
return false;
});
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
複製程式碼