1、ActivityThread:在Android中它就代表了Android的主线程,注意是代表而不是说它就是一个Thread类
这里,我们主要看main方法中的Looper相关的,其他的先忽略(注:不同版本的API对应的源码,会有点区别,但是关键地方一样,不用纠结这个,这里的ActivityThread,是API 26的)
public static final 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();
.....
}
2、主线程中的handler,可以处理系统级别的handler消息,其中包括:处理4大组件中的切换、通信、甚至处理返回键、Activity的启动模式、杀死进程等等
3、handler的创建
import android.os.Handler;
import android.os.Message;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
}
};
4、消息的创建
import android.os.Message
Message m= Message.obtain();
obtain()对应源码:
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
5、handler的使用过程中,Message的回收
一个Message(消息)被创建出来后,会被handler发送到到MessageQueue中,MessageQueue存在于Looper中
5.1、在使用Message的时候,我们从来没有关心过Message的回收,其实,也不用关心。系统会自动回收的。因为不可能在Message一被创建(放在MessageQueue中还未被使用)或从MessageQueue刚取出还没处理就回收,所有,直接去看Looper中的loop()。(即:Looper.loop();)
5.2、loop()对应源码
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the 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 slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg=" + msg.what);
}
}
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();
}
}
说明:
s1、for(;;)中Message msg = queue.next();不断的从MessageQueue(消息队列)中取消息,如果是空,就return;for循环这里,是对消息的轮询
s2、对于说明1中的空情况,我们可能会有疑问:什么时候会为空呢?
在ActivityThread中:
public void handleMessage(Message msg) {
switch (msg.what) {
......
}
}
有一种情况:
case EXIT_APPLICATION:
if (mInitialApplication != null) {
mInitialApplication.onTerminate();
}
Looper.myLooper().quit();
break;
再看Looper中的quit()
其中:MessageQueue mQueue
/**
* Quits the looper.
* <p>
* Causes the {@link #loop} method to terminate without processing any
* more messages in the message queue.
* </p><p>
* Any attempt to post messages to the queue after the looper is asked to quit will fail.
* For example, the {@link Handler#sendMessage(Message)} method will return false.
* </p><p class="note">
* Using this method may be unsafe because some messages may not be delivered
* before the looper terminates. Consider using {@link #quitSafely} instead to ensure
* that all pending work is completed in an orderly manner.
* </p>
*
* @see #quitSafely
*/
public void quit() {
mQueue.quit(false);
}
继续看MessageQueue中的quit方法
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
if (safe) {
removeAllFutureMessagesLocked();
} else {
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
其中:
removeAllFutureMessagesLocked()对应源码为:
private void removeAllFutureMessagesLocked() {
final long now = SystemClock.uptimeMillis();
Message p = mMessages;
if (p != null) {
if (p.when > now) {
removeAllMessagesLocked();
} else {
Message n;
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
break;
}
p = n;
}
p.next = null;
do {
p = n;
n = p.next;
p.recycleUnchecked();
} while (n != null);
}
}
}
removeAllMessagesLocked()对应源码:
private void removeAllMessagesLocked() {
Message p = mMessages;
while (p != null) {
Message n = p.next;
p.recycleUnchecked();
p = n;
}
mMessages = null;
}
这样看,就清楚了:用户退出程序的时候,MessageQueue清空消息,Looper中的循环loop取到空消息,在没有任何消息的情况下,loop会return
s3、注意一句话
msg.target.dispatchMessage(msg);
这里,是对消息的处理
msg.target就是handler,在这里,就是handler的回调
Handler中:
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
s4、继续往下看loop的源码,我们会看到一句话:
msg.recycleUnchecked();
在Message中
/**
* Recycles a Message that may be in-use.
* Used internally by the MessageQueue and Looper when disposing of queued Messages.
*/
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
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) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
s5、如果我们自己手动回收呢:代码如下:
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 100:
//do something...
msg.recycle();
break;
}
}
};
看看recycle的源码:
/**
* Return a Message instance to the global pool.
* <p>
* You MUST NOT touch the Message after calling this function because it has
* effectively been freed. It is an error to recycle a message that is currently
* enqueued or that is in the process of being delivered to a Handler.
* </p>
*/
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}
在结尾处,我们又看到了recycleUnchecked();
总结:在消息池中拿到一个Message,然后被handler放到消息队列中,Looper通过loop()(依赖其中的for循环),检查有没有消息,没有就return;有消息,就处理,处理完以后,Message自己会调用方法回收。不用我们自己手动回收。
如果我们自己在处理完消息后,在handleMessage中自己回收了(见上面的说明5),不为错,也证明思路严谨,但是,因为message自己会回收,所有在结果一样的情况下,反而会因为自己的收到回收,多消耗一点内存(因为回收了2次。虽然这个消耗的内存,可以忽略不计,可是,毕竟对结果没有任何影响)。
6、handler的移除
在用Activity的时候,在onDestroy方法中,建议加上消息的移除
例如,在Activity中,用handler发了消息100,
@Override
protected void onDestroy() {
if (handler != null && handler.hasMessages(100)) {
handler.removeMessages(100);
}
super.onDestroy();
}
handler中
/**
* Remove any pending posts of messages with code 'what' that are in the
* message queue.
*/
public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null);
}
MessageQueue中
void removeMessages(Handler h, int what, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
// Remove all messages at front.
while (p != null && p.target == h && p.what == what
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
// Remove all messages after front.
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && n.what == what
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}