先说明一下,自己的代码是用kotlin写的,源码还是是java
不说主线程使用handler.大家都会的,这儿直接在子线程中创建和使用Handler,然后配合部分源码来看看
先在子线程创建一个handler
var handler : Handler?=null//创建一个全局变量handler
//创建子线程,在子线程中创建handler
Thread(Runnable {
handler = object : Handler() {
override fun handleMessage(msg: Message?) {
super.handleMessage(msg)
when (msg?.what) {
0 -> runOnUiThread { showToast("子线程的数据") }
}
}
}
}).start()
然后呢,上面那段代码一运行就会报错的,常用Handler的应该了解,handler都需要对应一个Looper,而这儿的代码并没有创建looper,所以要调用
Looper.prepare()
来创建looper对象
然后再调用
Looper.loop()
开启循环来读取MessageQueue中的Message,所以最后的代码就变为了
Thread(Runnable {
Looper.prepare()
handler = object : Handler() {
override fun handleMessage(msg: Message?) {
super.handleMessage(msg)
when (msg?.what) {
0 -> runOnUiThread { showToast("子线程的数据") }
}
}
}
Looper.loop()
}).start()
这是我们最常用的写法
为什么我们在主线程中没有调用这个looper的两个方法呢,因为在主线程的main方法中已经调用过的了
public static void main(String[] args) {
........
Looper.prepareMainLooper();//这儿就调用了创建
........
Looper.loop();//这儿开启循环,会一直卡在这儿的,直到调用了looper.quit(),但是看代码就明白,主线程调用了quit就会抛异常的啦
throw new RuntimeException("Main thread loop unexpectedly exited");
}
好了,不管主线程还玩了些什么,我们主要从子线程使用Handler那里开始看代码,基本就够了,现在来根据这三段代码分析一下到底干了些什么
首先:Looper.prepare()
public static void prepare() {
prepare(true);//调用自己的静态方法
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {//判断sThreadLocal.get()是否未空,看下面的set就知道,这里的get\取出来的就是looper,
//就是说如果已经创建了looper,就抛异常,没有就创建
//所以如果今后有人问你在主线程中调用Looper.prepare()有没有问题的时候,你就知道了噻,因为主线程已经创建了looper
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));//这儿就创建looper,然后放入sThreadLocal中,后面handler要从这里面取looper
}
我们再来看看这里面又干了些什么
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
原来就是创建了messagequeue和取到了当前线程
我们又来看看MessageQueue又干了些什么
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;//这里的值需要记住,子线程这儿传的true,主线程传的false,这个后面要讲
mPtr = nativeInit();//这是个native方法,看不到代码,只晓得返回了一个mPtr
}
好,到这儿,looper,MessageQueue就都创好了
接下来就是Handler,来看看Handler分别调用了些什么方法
public Handler() {
this(null, false);
}
handler有很多个构造方法,我们就只讲这个一直用的,其他的自己有时间去看源码
调用了自己的构造方法,然后继续调用
public Handler(Callback callback, boolean async) {
.......//这儿先不管
//这儿得到当前handler所绑定的looper
mLooper = Looper.myLooper();//就是之前的sThreadLocal.get();,取出当前线程的looper
if (mLooper == null) {//如果looper没有创建,就要抛异常:创建handler的线程没有调用Looper.prepare()去创建looper
//所以为什么在子线程中创建Handler要先调用Looper.prepare()的原因
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
//走到这儿就表示有looper,并从looper中得到messageQueue
mQueue = mLooper.mQueue;
//得到callback,但是我们这儿传的null,所以就没有,但是可以记住这个接口
mCallback = callback;
mAsynchronous = async;
}
final Callback mCallback;//Handler中的Callback
然后就要开始重点了
Looper.loop()
这里面做了一些什么呢,我们从发送一个消息来开始说明,毕竟从流程上面来讲,这种容易懂一些
handler?.sendEmptyMessage(0)//使用最简单的发送消息方法,发送一个what==0的message
现在来根据步骤看看到底走了些什么地方(我把这些方法放在一起,比较容易看)
public final boolean sendEmptyMessage(int what){
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();//我发送的是空msg,所以这里他要创建一个
//官方推荐用Message.obtain()创建,好像是方便回收还是怎么的
msg.what = what;
//这里的delayMillis就是我们有时候调用的延迟发送的那个时间,这儿不延迟,所以就用的0
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis < 0) {//看代码的话,传负的也不会报错,给换成了0而已
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
//这儿的uptimeMillis其实是系统当前时间+延迟时间得到最后发送的时间
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {//如果没有queue,就表示MessageQueue没有创建好,可能就是没有调用looper.prepare()
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
//得到了MessageQueue,msg,发送时间
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//给msg.target赋值,这儿赋值this,其实就是Handler,就是说msg.target就是一个Handler,后面要用到
msg.target = this;
if (mAsynchronous) {//创建Handler的时候不是传了一个async吗,这儿就用到了,不过我们用的这个他自己传的false,就不管这里面的
msg.setAsynchronous(true);
}
//这儿就是吧msg和发送时间保存到MessageQueue里面去
return queue.enqueueMessage(msg, uptimeMillis);
}
看吧,其实handler在发送这儿做了些啥呢,说白了就直是吧msg存到MessageQueue里面
现在来看看MessageQueue里面的enqueueMessage干了些啥
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {//看看message绑定的handler有没有咯
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {//看看这个msg是否被使用咯
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {//判断是否已经调用了quit()方法,后面会讲到这个值
//这里并没有抛异常哟,只是打印了错误信息,说都已经退出啦,不能发消息了
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状态改了
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;
//以上的话就是把msg放入MessageQueue里面咯,有些细节我也不是很清楚,等有机会再好好理解一下这儿了
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
好了,到这儿就表示已经把Message放入MessageQueue里面了,接下来就是最重要的Looper.loop()了
public static void loop() {
final Looper me = myLooper();
if (me == null) {//先取出looper看有没有,没有就抛异常咯
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//取出MessageQueue
......
//其他的都先不看,看主要的looper怎么从MessageQueue中取出message再传递给Handler的
for (;;) {//这儿一个死循环,一直循环读取MessageQueue中的Message,直到返回null
//但是只有调用quit方法才会返回null,其他时候返回了啥我也还没看明白,就是我想闹懂的为什么looper死循环不会堵塞主线程的地方
Message msg = queue.next(); // 通过上面的死循环不停的从MessageQueue中读取Message
if (msg == null) {
// No message indicates that the message queue is quitting.
return;//quit了后,这个死循环就退出去了,所以感觉呢,子线程的handler用完了最好quit一下
}
......
try {
msg.target.dispatchMessage(msg);
//上面我们也说到了,msg.target==Handler,所以这儿就是调用Handler的发送方法了
......
} finally {
......
}
.......
msg.recycleUnchecked();
}
}
public void quit() {
mQueue.quit(false);//调用了MessageQueue的quit方法
}
//MessageQueue的quit()
void quit(boolean safe) {
if (!mQuitAllowed) {//还记的前面说的主线程传的false,子线程传的true吗,这儿就告诉我们主线程不能调用quit()
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {//如果已经退出了
return;
}
mQuitting = true;//改变当前MessageQueue的状态咯,改为已经退出
if (safe) {//这里移除所有延迟发送的消息
removeAllFutureMessagesLocked();
} else {//移除全部消息,无论是立刻发送的还是延迟发送的
removeAllMessagesLocked();
}
//移除那儿就不讲了,没几句代码得
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
然后就是Handler的发送了
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//判断msg的callback是否为空,msg的callback是一个Runnable
handleCallback(msg);//然后里面就是只想Runable的run方法咯
//这里的呢,就是handler?.post(Runnable { //do something })
} else {
if (mCallback != null) {//这儿的mCallback是一个接口,Handler.Callback
if (mCallback.handleMessage(msg)) {//接口回调,返回msg,这就是new Handler(callback)
return;
}
}
handleMessage(msg);//这儿就是最常见的使用了
}
}
好了,基本上handler从发送到收到消息的基本流程,还有一些地方我也不是很明白,所以就没写进去,免得误人子弟,如果有什么不对的地方欢迎指正
