Handler,Looper,Thread,Message,MessageQueue
【1】Looper如何和Thread联系起来?
答:以主线程为例解释:
在ActivityThread类中的程序的入口,即main方法,该方法中调用了:
Looper.prepareMainLooper();
Step:接下来我们解析Looper类中的该方法:
public static void prepareMainLooper() {
prepare(false); synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared."); }
sMainLooper = myLooper(); }
}
官方对该方法的解释:
(1)将当前线程初始化为looper,将其标记为应用程序的主looper。
(2)应用程序的主looper是由Android环境创建的,所以你应该永远不要自己调用该方法。
Step:接下来我们解析:
prepare(false);
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));}
官方对该方法的解释:
(1)该方法让你有机会创建handlers,然后引用这个looper,然后才开始真正循环(loop)。
(2)调用此方法后一定要调用loop(),通过调用quit()来结束它。
Step:接下来我们解析:sThreadLocal.set(new Looper(quitAllowed));
(1)首先我们关注创建Looper对象:Looper looper = new Looper(quitAllowed)
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread();}
这里主要是:
(1)创建了MessageQueue的对象mQueue;
(2)创建了Thread的对象mThread;
Thread.currentThread()方法可以获取到当前的线程,当应用程序启动的时候,系统会为该应用程序创建一个线程,我们叫它主线程。
(2)其次我们关注Looper对象的存储:sThreadLocal.set(looper)
我们看看sThreadLocal是什么东东?
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
官方对ThreadLocal的解释:
用来实现线程本地存储,即每个线程的变量有自己对应的值。
所有的线程共享相同的ThreadLocal对象,但是每个线程访问它时都会看到不同的值,并且有一个线程更改不会影响其他线程。
Step:接下来我们解析:set(looper)
public void set(T value) {
Thread currentThread = Thread.currentThread(); Values values = values(currentThread); if (values == null) {
values = initializeValues(currentThread); }
values.put(this, value);}
官方对该方法的解释:
为当前线程设置此变量的值。
这里不对ThreadLocal类进行深入的了解,到这里我们知道使用该类可以实现存储Thread和Looper就可以了,类似于(key-value)。
因为Thread默认没有与它关联的消息循环,(Thread默认不能进行消息循环)
要创建一个,我们在运行循环的线程中调用prepare(),
然后调用loop()方法让他处理消息,
最后调用quit()方法推出循环
Looper最重要的方法以及顺序:prepare() -> loop() ->quit()
实际开发中的使用:参考HandlerThread
【1】extends Thread
【2】Looper.prepare() //将Thread初始化为looper
【3】创建一个或者多个Handler,用来处理message
【4】Looper.loop() //分发message,直到loop被告知quit()
【2】Handler如何和Thread联系起来?
主要从分析Handler源码来解析:
Step:先看默认构造函数:
public Handler() {
this(null, false);}
官方对该构造函数的解释:
默认构造函数将该Handler与当前线程的Looper关联起来。如果此线程没有looper,该Handler将无法接收Message,因此会抛出异常。
Step:再看看另一个构造函数:
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;}
官方对该构造函数的解释:
对于具有指定的回调接口的当前Thread使用Looper,并设置该Handler是否应该是异步的。
Handler默认情况下是同步的,除非此构造函数用于创建严格异步的。
mLooper:在Looper中通过prepare()方法创建的,这样Handler就和Looper联系起来了,【同时和Thread联系起来。】
mQueue:Handler中的MessageQueue和Looper中的MessageQueue是一致的。
Step:接着看Handler的两个主要用途:
【1】调度message 和 runnable ,在未来的某个点执行。
【2】在与自己不同的线程上执行某个事件。
调度消息可以通过如下方法完成,大致有两类型:post 和 send
post方式允许在接收到消息时将Runnable对象入队;
send方式允许在接收到消息时将Message对象入队;
Step:关于post方式做如下说明:
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);}
官方解释:
将Runnable添加到MessageQueue.Runnable将在Handler所在的Thread中运行。
Step:再看看getPostMessage(r):
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain(); m.callback = r; return m;}
将Runnable用Message包裹起来,以Message的形式发送出去。
记住:无论是post方式,还是send方式,最终都只调用一个方法:
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);}
官方解释:
将Message置入MessageQueue中。(这里时间先不做解释了)
Step:再看看enqueueMessage()方法:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this; if (mAsynchronous) {
msg.setAsynchronous(true); }
return queue.enqueueMessage(msg, uptimeMillis);}
重点:msg.target = this;这是非常重要的,因为Looper中的loop() 方法会用到它,即:msg.target.dispatchMessage(msg);
目的是要求发送Message的Handler和处理Message的Handler是一致的。
Step:接下来重点就是MessageQueue的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;}
至此,Message已经放入MessageQueue中了;
Step:接下来就是从MessageQueue中取Message了,这时候就需要发挥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(); }
}
这里重点看:msg.target.dispatchMessage(msg)
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg); } else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return; }
}
handleMessage(msg); }
}
这里我们看到它分情况处理了,msg.callback是否为null。
如果msg.callback不为null,说明传递过来的是Runnable,然后进行handleCallback(msg)
private static void handleCallback(Message message) {
message.callback.run();}
如果msg.callback为null,说明传递过来的是Message,然后进行handleMessage(msg)
public void handleMessage(Message msg) {
}
我们需要在run()方法和handleMessage()方法中写自己的实现。
【3】通过对【1】和【2】的分析,我发现:
我们主要了解Thread,Looper,Handler它们三个之间的关系就可以了,Message和MessageQueue可以把它们当作媒介就可以。
出场顺序是这样的:Thread -> Looper -> Handler
Thread创建后,就需要对Looper进行操作,主要是执行两个方法:prepare(),loop(), 这是准备工作。
然后就是对Handler的使用,创建Handler对象,并将其和Looper联系起来,并和Thread联系起来,
Handler就可以发挥它强大的功能。
【4】思考:
UI线程是如何创建的?
应用启动时,系统会为应用创建一个名为主线程的执行线程。主线程负责将事件分派给相应的用户界面小部件,其中包括绘图事件。
此外,UI线程也是应用与Android UI工具包组件进行交互的线程。
UI线程才能处理UI相关的操作,为什么?
答:Android UI工具包不是线程安全的。因此,单线程模型确保UI不能被不同的线程同时修改。
Android关于线程的详细说明:https://developer.android.com/guide/components/processes-and-threads.html
【5】Handler的工作原理:
Handler创建时会采用当前线程的Looper来构建内部的消息循环系统。接下来看Handler的运行机制
【6】ThreadLocal:
在不同的线程中访问的是同一个ThreadLocal对象,但是他们通过ThreadLocal获取到的值是不同的。
why? ->不同线程访问同一个ThreadLocal的get()方法,ThreadLocal内部会从各自的线程中取出一个数组,
推荐阅读
-
Handler,Looper,MessageQueue流程梳理
-
Android异步2:深入详解 Handler+Looper+MessageQueue
-
Android Handler 机制 - Looper,Message,MessageQueue
-
handler,message,looper,messagequeue
-
Handler,Looper,Thread,Message,MessageQueue
-
Handler、Looper、Message、MessageQueue
-
Looper,MessageQueue,Message,Handler
-
异步消息处理(Message, Handler, MessageQueue, Looper)
-
Android消息通信机制Handler详解,Handler,Looper,MessageQueue,源码解析,讲解这几个类怎么配合工作的
-
Android消息处理机制(Handler、Looper、MessageQueue与Message)