面试的时候经常被问到Handler机制 以前自己的做法就是去网上找答案 听他们各种分析 最后还是记不住
总结
1. Looper和线程是一对一
2. Looper和MessageQueue 是 一对一 因为就是他自己创建的
3. 一个线程下的Handler 如果不去指定Looper的时候 是公用一个Looper的 多对一
一个handler对象依赖一个Looper 这个Looper是通过ThreadLocal来进行存放的 也就是一个线程只有一个 通过Looper.prepare来创建一个Looper 创建的同时Looper里会创建一个MessageQueue
创建handler的时候 他会把Looper 和 Looper里的MessageQueue做为自己的成员变量
当handler sendMessage的时候 就把Message 放到MessageQueue里（这个MessageQueue 和 自己的Looper里的是一个） 同时把自己当作Message的target message依赖handler
Looper看起来是一个死循环 不停的从自己的MessageQueue里通过next方法取值 MessageQueue是一个链表结构
如果没有值的时候会阻塞
如果有值就把Message取出来 找到他的target也就是发送他的Handler 然后通过dispatchMessage方法 交给handler的回调处理
其实Handler机制只要你去看android的源码 你就会发现他特别简单(比进程间通讯简单多了)
- 既然是handler机制 那我们就去看一下handler的源码
创建handler的时候 无参 一个参 两个参数 都会走下边这个构造
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class klass = getClass();
/**
* isAnonymousClass 如果是匿名内部类 返回true
* isMemberClass 如果是内部非静态类 返回true
* isLocalClass 在方法里声明的类 返回true
* getModifiers 返回一个int值
* Modifier.STATIC 0x00000008 二进制 0000 1000 如果和他与作是0 有很多
如果和他与非0 那第四位必须是1 只能是static class
* 下边这个语句的意思是 你创建的handler不能内存泄露
*/
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;
}
这个构造函数
- 先拿到当前handler对象的class 判断 你有没有内存泄露 有就给你个提示 那几个方法我注释过了
- 通过Looper.myLooper(); 来拿到一个Looper对象 mLooper是handler的成员变量 如果没有looper那就报错 说你没有调用Looper.prepare()
总结 根据上边两条我们知道Handler里依赖一个Looper
然后我们继续看looper的源码 就通过上边的Looper.myLooper();点进去
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
他用了一个ThreadLocal.get() 这个ThreadLocal是存放Looper对象的
ThreadLocal这个放后边 我们只要知道他可以保证每个线程只有一个Looper对象就可以了
那他是在哪里set进去的呢 我们在Looper的源码里找到
public static void prepare() {
prepare(true);
}
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));
}
通过prepare来new Looper 所以我们在子线程里创建handler的时候 如果没有调用这个方法 并且我们也没有给指定一个Looper 那就会抛上边2里提到的异常
looper的构造里创建了一个MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
也就是说Handler依赖Looper Looper依赖MessageQueue 而Looper是每个线程都只有一个 现在看一下发送消息 和接收消息的过程
无论你是sendMessage 还是sendEmptyMessage 走的都是下边这个方法
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);
}
把message放到MessageQueue里 这个MessageQueue是通过Handler的Looper拿到的 然后把当前的handler做为message的target
接下来就是处理消息了 一个重要的方法Looper.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();
}
}
代码一大堆 主要是 for (;;) 来从Message msg = queue.next(); 里取值
如果没有就阻塞了
如果有 那就msg.target.dispatchMessage(msg); 交给对应的handler处理
一次消息发送就结束了
在看下Handler的构造
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
三个参数 第一个Looper每个线程只有一个 第二个回调函数 第三个 是否支持异步
- 主线程自带一个Looper 我们可以用主线程的Looper来做为参数
- 如果是在子线程中 你必须要给Handler指定Looper 通过prepare方法
- 你只要在B线程中拿到A线程的Handler 就可以实现他俩的交互了
ThreadLocal如何做到每个线程只有一个的 可以看这个
https://blog.csdn.net/xieyuooo/article/details/8599266