Android Handler消息机制源码分析——第二部分:Message与Handler

Android Handler消息机制源码分析——第二部分:Message与Handler

Message

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
/**
* Message代表了一个消息,消息中包含了描述信息与若干数据,
* Message主要通过Handler对象进行发送。
* Message中有两个int字段arg1和arg2以及Object类型的obj字段供你使用
* 你可以在这里设置一些额外的信息。
* 如果要进行其他的数据传出可以使用setData()方法,
* data是Bundle类型的字段,你可以在这个字段中设置你想要传输的数据
*
* 注意:虽然Message的构造方法是共有的,
* 但是最好还是使用Message.obtain()方法来获取Message对象
* 因为使用该方法可以复用Message回收池中的Message对象
*/
public final class Message implements Parcelable {
/**
* 用户自定义消息码,用来标识每个信息。
* 一个消息队列可能处理多个Handler发出的消息,
* 如果每个Handler对自己的消息都有自己的命名规则,
* 就可以很好的避免与其他Handler发送的消息标识产生冲突
*/
public int what;

/**
* arg1和arg2这两个字段能够用来保存一些简单的信息
* 如果你想要传递更多的数据最好使用setData(Bundle)方法,
* 如果是简单的数据使用arg1和arg2就足够了,可以避免创建对象(Bundle还是蛮耗资源的)
*/
public int arg1;

public int arg2;

/**
* 你想发送给接受者的任意对象,
* 当使用Messenger发送跨进程的消息时,
* 那这个对象还需要实现Parcelable接口了
* 对于其他更复杂的数据最好还是使用setData(Bundle)进行传递
*
* <p>注意:在Android 2.2之前还不支持Parcelable接口
*/
public Object obj;

/**
* Messenger涉及跨进程通信,这里不做深入研究
* Optional Messenger where replies to this message can be sent. The
* semantics of exactly how this is used are up to the sender and
* receiver.
*/
public Messenger replyTo;

/**
* 这是一个可选字段,也是用来标识发送的信息。
* 这个字段只在使用Messenger跨进程通信才会使用,其他情况下它都是-1
*/
public int sendingUid = -1;

/** If set message is in use.
* This flag is set when the message is enqueued and remains set while it
* is delivered and afterwards when it is recycled. The flag is only cleared
* when a new message is created or obtained since that is the only time that
* applications are allowed to modify the contents of the message.
*
* It is an error to attempt to enqueue or recycle a message that is already in use.
*/
/*package*/ static final int FLAG_IN_USE = 1 << 0; //标志位:标识消息正在使用中

/** If set message is asynchronous */
/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1; //标志位:标识该消息是异步消息

/** Flags to clear in the copyFrom method */
/*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;

/*package*/ int flags; //存储上面的几个标志位

/*package*/ long when; //消息需要在何时处理

/*package*/ Bundle data; //消息所携带的数据,更直接的说这应该是个数据包(小数据没必要存在这里)

/*package*/ Handler target; //消息的处理者

/*package*/ Runnable callback; //消息的回调(有这个字段通常就不会去执行target的handleMessage方法)

// 存储下一个消息(这就是MessageQueue的消息队列的存储机制,实际上就是个单链表)
/*package*/ Message next;

// 这几个字段是Message的回收池,
// 或者叫做缓冲池(这就是建议使用Message.obtain方法获取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;

private static boolean gCheckRecycle = true;

//////////////////////////////////////////////////////////////////////////////////////////////
/**
* 从全局的缓冲池中创建一个Message对象,
* 使用该方法避免了重复创建Message对象
* 使用全局缓冲池达到对象复用的目的
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) { //取出缓冲池链表中的第一个Message对象
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}

/**
* 将传入的Message对象信息拷贝到缓冲池中的一个对象中
*/
public static Message obtain(Message orig) {
Message m = obtain();
m.what = orig.what;
m.arg1 = orig.arg1;
m.arg2 = orig.arg2;
m.obj = orig.obj;
m.replyTo = orig.replyTo;
m.sendingUid = orig.sendingUid;
if (orig.data != null) {
m.data = new Bundle(orig.data);
}
m.target = orig.target;
m.callback = orig.callback;

return m;
}
/**
* 下面的obtain功能类似
*/
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;

return m;
}
public static Message obtain(Handler h, Runnable callback) {
Message m = obtain();
m.target = h;
m.callback = callback;

return m;
}
public static Message obtain(Handler h, int what) {
Message m = obtain();
m.target = h;
m.what = what;

return m;
}
public static Message obtain(Handler h, int what, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.obj = obj;

return m;
}

public static Message obtain(Handler h, int what, int arg1, int arg2) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;

return m;
}
public static Message obtain(Handler h, int what,
int arg1, int arg2, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;
m.obj = obj;

return m;
}
//////////////////////////////////////////////////////////////////////////////////////////////

/** @hide */
public static void updateCheckRecycle(int targetSdkVersion) {
if (targetSdkVersion < Build.VERSION_CODES.LOLLIPOP) {
gCheckRecycle = false;
}
}

/**
* 将消息回收进缓冲池中
* 正在使用的Message无法回收(也就是已经入队的消息或正在处理的消息)
*/
public void recycle() {
if (isInUse()) { //正在使用无法回收
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}

/**
* 不检查是否正在使用,直接回收该消息
* 这个是包内函数主要供MessageQueue和Looper在处理完消息后使用
*/
void recycleUnchecked() {
// 数据归零
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++;
}
}
}

/**
* 从指定的Message中拷贝到该Message,对于Bundle类型的data字段执行的是浅拷贝
* 没有拷贝o对象的when时间戳和target、callback字段
*/
public void copyFrom(Message o) {
this.flags = o.flags & ~FLAGS_TO_CLEAR_ON_COPY_FROM;
this.what = o.what;
this.arg1 = o.arg1;
this.arg2 = o.arg2;
this.obj = o.obj;
this.replyTo = o.replyTo;
this.sendingUid = o.sendingUid;

if (o.data != null) {
this.data = (Bundle) o.data.clone();
} else {
this.data = null;
}
}

/**
* 返回该消息的处理时间,毫秒为单位的时间戳
*/
public long getWhen() {
return when;
}

public void setTarget(Handler target) {
this.target = target;
}

/**
* 获取这个消息的处理对象也就是Handler的实现类
* 对象必须要实现handleMessage(Message)方法.
*/
public Handler getTarget() {
return target;
}

/**
* 获取回调接口,当该消息被处理的时候该回调接口会被调用
*/
public Runnable getCallback() {
return callback;
}

/**
* 获取存储数据的Bundle对象,这个对象是通过setData方法设置的。
* 注意:当通过Messenger进行跨进程数据传输时,
* 你还需要通过调用setClassLoader(ClassLoader)方法为你的Bundle设置类加载器
* 类加载器主要是用来在其他进程来实例化Bundle中的对象
* @see #peekData()
* @see #setData(Bundle)
*/
public Bundle getData() {
if (data == null) {
data = new Bundle();
}

return data;
}

/**
* 与getData()不同,这个可能返回null
* @see #getData()
* @see #setData(Bundle)
*/
public Bundle peekData() {
return data;
}

/**
* Sets a Bundle of arbitrary data values. Use arg1 and arg2 members
* as a lower cost way to send a few simple integer values, if you can.
* @see #getData()
* @see #peekData()
*/
public void setData(Bundle data) {
this.data = data;
}

/**
* 可以通过该方法来指定Message的处理者
*/
public void sendToTarget() {
target.sendMessage(this);
}

/**
* 判断该消息是否为异步消息,这里涉及到上一篇MessageQueue中讲到的同步消息拦截器(SyncBarrier)。
* SyncBarrier可以拦截同步消息,所以可以通过setAsynchronous方法将消息设置为异步的。
*
*这个方法是用来查看消息是否为异步的。
* @hide
*/
public boolean isAsynchronous() {
return (flags & FLAG_ASYNCHRONOUS) != 0;
}

/**
* 是否将将消息设置为异步的
* 对于为什么要异步消息,可以查看上篇MessageQueue.enqueueSyncBarrier方法与next方法
* @hide
*/
public void setAsynchronous(boolean async) {
if (async) {
flags |= FLAG_ASYNCHRONOUS;
} else {
flags &= ~FLAG_ASYNCHRONOUS;
}
}

//消息是否正在使用中(消息已在消息队列中或消息正在处理)
/*package*/ boolean isInUse() {
return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
}

/*package*/ void markInUse() {
flags |= FLAG_IN_USE;
}

/** Message构造方法(但是还是建议使用Message.obtain()方法来获取Message对象)
*/
public Message() {
}

@Override
public String toString() {
return toString(SystemClock.uptimeMillis());
}

String toString(long now) {
StringBuilder b = new StringBuilder();
b.append("{ when=");
TimeUtils.formatDuration(when - now, b);

if (target != null) {
if (callback != null) {
b.append(" callback=");
b.append(callback.getClass().getName());
} else {
b.append(" what=");
b.append(what);
}

if (arg1 != 0) {
b.append(" arg1=");
b.append(arg1);
}

if (arg2 != 0) {
b.append(" arg2=");
b.append(arg2);
}

if (obj != null) {
b.append(" obj=");
b.append(obj);
}

b.append(" target=");
b.append(target.getClass().getName());
} else {
b.append(" barrier=");
b.append(arg1);
}

b.append(" }");
return b.toString();
}

// 下面都是Parcelable接口的实现,这里就不再往下解释了
public static final Parcelable.Creator<Message> CREATOR
= new Parcelable.Creator<Message>() {
public Message createFromParcel(Parcel source) {
Message msg = Message.obtain();
msg.readFromParcel(source);
return msg;
}

public Message[] newArray(int size) {
return new Message[size];
}
};

public int describeContents() {
return 0;
}

public void writeToParcel(Parcel dest, int flags) {
if (callback != null) {
throw new RuntimeException(
"Can't marshal callbacks across processes.");
}
dest.writeInt(what);
dest.writeInt(arg1);
dest.writeInt(arg2);
if (obj != null) {
try {
Parcelable p = (Parcelable)obj;
dest.writeInt(1);
dest.writeParcelable(p, flags);
} catch (ClassCastException e) {
throw new RuntimeException(
"Can't marshal non-Parcelable objects across processes.");
}
} else {
dest.writeInt(0);
}
dest.writeLong(when);
dest.writeBundle(data);
Messenger.writeMessengerOrNullToParcel(replyTo, dest);
dest.writeInt(sendingUid);
}

private void readFromParcel(Parcel source) {
what = source.readInt();
arg1 = source.readInt();
arg2 = source.readInt();
if (source.readInt() != 0) {
obj = source.readParcelable(getClass().getClassLoader());
}
when = source.readLong();
data = source.readBundle();
replyTo = Messenger.readMessengerOrNullFromParcel(source);
sendingUid = source.readInt();
}
}

Handler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
/**
* Handler是发送和处理消息的地方,也就是整个Handler框架的头跟尾。
* 在一个线程中你可以创建多个Handler对象,
* 每个Handler示例对象都关联了该线程的Looper和MessageQueue。
* Handler在创建的时候就绑定了它所在的线程的MessageQueue(不需要开发者绑定)
*
* <p>发送消息主要一下两类:
* (1) 发送一个Runnable在指定的时间执行
* (该方法事实上是通过调研那个getPostMessage方法将Runnable封装到Message对象中)
* boolean post(Runnable r)
* boolean postAtTime(Runnable r, long uptimeMillis)
* boolean postDelayed(Runnable r, long delayMillis)
* boolean postAtFrontOfQueue(Runnable r)
* (2) 发送一个消息在指定的时候分发到Handler.handleMessage(Message)方法中
* boolean sendMessage(Message msg)
* boolean sendEmptyMessage(int what)
* boolean sendEmptyMessageDelayed(int what, long delayMillis)
* boolean sendEmptyMessageAtTime(int what, long uptimeMillis)
* boolean sendMessageDelayed(Message msg, long delayMillis)
* boolean sendMessageAtTime(Message msg, long uptimeMillis)
*
* 以上两中类型的方法最终都会辗转调用最后那个方法sendMessageAtTime
* 不同的是前者回调的是Message.callable.run方法(也就是指定的Runnable对象的run方法)
* 后者回调的是Message.target.handleMessage方法(也就是开发者继承Handler后重载的handleMessage)
*/
public class Handler {
/*
*/
private static final boolean FIND_POTENTIAL_LEAKS = false;
private static final String TAG = "Handler";

/**
* 类似于代理模式
* Handler与Callback的关系类似于Thread与Runnable的关系
*/
public interface Callback {
public boolean handleMessage(Message msg);
}

/**
* 处理消息的方法
* 该方法就是子类需要实现的方法
*/
public void handleMessage(Message msg) {
}

/**
* 消息分发
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//调用Message.callback.run方法(这就是post类型的方法处理入口)
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
// 这里mCallback就是前面的Callback接口
return;
}
}
handleMessage(msg); //最后调用Handler.handleMessage方法
}
}

/**
* 默认构造函数
*/
public Handler() {
this(null, false);
}

/**
* 看了dispatchMessage方法,这个构造就很容易理解
*/
public Handler(Callback callback) {
this(callback, false);
}

/**
* 开发者提供一个Looper从而替换默认的Looper
*/
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}

/**
* Handler默认是同步的,可以通过该构造修改默认是否默认异步。
* 异步的Handler发送每个消息时会调用Message.setAsynchronous(boolean)设置消息为异步
* 异步消息的作用主要是不受SyncBarrier同步拦截器的影响
*
* @hide
*/
public Handler(boolean async) {
this(null, async);
}

/**
* @hide
*/
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(); //获取当前线程的Looper(默认Looper)
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;
}

/**
* @hide
*/
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}

public String getMessageName(Message message) {
if (message.callback != null) {
return message.callback.getClass().getName();
}
return "0x" + Integer.toHexString(message.what);
}
//////////////////////////////////////////////////////////////////////////////////////////////
//obtainMessage都是间接调用Message.obtain(对象复用的功能前面也说过了)
public final Message obtainMessage()
{
return Message.obtain(this);
}

public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}

public final Message obtainMessage(int what, Object obj)
{
return Message.obtain(this, what, obj);
}

public final Message obtainMessage(int what, int arg1, int arg2)
{
return Message.obtain(this, what, arg1, arg2);
}

public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
{
return Message.obtain(this, what, arg1, arg2, obj);
}
//////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////
// post类型-->Runnable填充Message.callback字段
// post方法最终会辗转调用 sendMessageAtTime(Message msg, long uptimeMillis) 方法
// post类型与send类型的区别可以参考dispatchMessage方法
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}

public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
// getPostMessage来填充Message.callback字段
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}

public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}

public final boolean postAtFrontOfQueue(Runnable r)
{
return sendMessageAtFrontOfQueue(getPostMessage(r));
}
//////////////////////////////////////////////////////////////////////////////////////////////
public final boolean runWithScissors(final Runnable r, long timeout) {
if (r == null) {
throw new IllegalArgumentException("runnable must not be null");
}
if (timeout < 0) {
throw new IllegalArgumentException("timeout must be non-negative");
}

if (Looper.myLooper() == mLooper) {
r.run();
return true;
}

BlockingRunnable br = new BlockingRunnable(r);
return br.postAndWait(this, timeout);
}

public final void removeCallbacks(Runnable r)
{
mQueue.removeMessages(this, r, null);
}

public final void removeCallbacks(Runnable r, Object token)
{
mQueue.removeMessages(this, r, token);
}
//////////////////////////////////////////////////////////////////////////////////////////////
// send方式的方法最终都辗转调用sendMessageAtTime(Message msg, long uptimeMillis)方法
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);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////
// 消息入队
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis); //调用MessageQueue.enqueueMessage
}
//////////////////////////////////////////////////////////////////////////////////////////////
public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null);
}

public final void removeMessages(int what, Object object) {
mQueue.removeMessages(this, what, object);
}

public final void removeCallbacksAndMessages(Object token) {
mQueue.removeCallbacksAndMessages(this, token);
}

public final boolean hasMessages(int what) {
return mQueue.hasMessages(this, what, null);
}

public final boolean hasMessages(int what, Object object) {
return mQueue.hasMessages(this, what, object);
}

public final boolean hasCallbacks(Runnable r) {
return mQueue.hasMessages(this, r, null);
}

public final Looper getLooper() {
return mLooper;
}

public final void dump(Printer pw, String prefix) {
pw.println(prefix + this + " @ " + SystemClock.uptimeMillis());
if (mLooper == null) {
pw.println(prefix + "looper uninitialized");
} else {
mLooper.dump(pw, prefix + " ");
}
}

@Override
public String toString() {
return "Handler (" + getClass().getName() + ") {"
+ Integer.toHexString(System.identityHashCode(this))
+ "}";
}

// 下面与Messnger相关的都属于跨进程通信
final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
return mMessenger;
}
}

private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
msg.sendingUid = Binder.getCallingUid();
Handler.this.sendMessage(msg);
}
}

private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}

private static Message getPostMessage(Runnable r, Object token) {
Message m = Message.obtain();
m.obj = token;
m.callback = r;
return m;
}

//处理msg.callback情况
private static void handleCallback(Message message) {
message.callback.run();
}

final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;

private static final class BlockingRunnable implements Runnable {
private final Runnable mTask;
private boolean mDone;

public BlockingRunnable(Runnable task) {
mTask = task;
}

@Override
public void run() {
try {
mTask.run();
} finally {
synchronized (this) {
mDone = true;
notifyAll();
}
}
}

public boolean postAndWait(Handler handler, long timeout) {
if (!handler.post(this)) {
return false;
}

synchronized (this) {
if (timeout > 0) {
final long expirationTime = SystemClock.uptimeMillis() + timeout;
while (!mDone) {
long delay = expirationTime - SystemClock.uptimeMillis();
if (delay <= 0) {
return false; // timeout
}
try {
wait(delay);
} catch (InterruptedException ex) {
}
}
} else {
while (!mDone) {
try {
wait();
} catch (InterruptedException ex) {
}
}
}
}
return true;
}
}
}