目录
前言
Handler使用，请参见：Handler总结和补充_fdsafwagdagadg6576的专栏-CSDN博客
正文
Hander源码机制包括四部分源码:
Handler源码,Looper源码Message源码,Messagequeue源码.
分成java层和native层.
消息流程：
handler---messageQueue---Looper---hander,消息发送---消息接收---消息分发---消息处理.
类图关系
1 Handler类
1.1 Handler 构造函数初始化
- 无参数构造函数
public class Handler {
/**我们通常用于创建Handler的构造方法之一*/
public Handler() {
this(null, false);
}
//===========step1: 构造函数====================
public Handler(Callback callback, boolean async) {
......
//=======step2://重点;获取Looper(messagequeue管理者)=== /
mLooper = Looper.myLooper();
//=======step3: 获取Looper的Messagequeue=====
mQueue = mLooper.mQueue;
//回调函数默认是Null
mCallback = callback;
//设置消息是否为异步处理方式
mAsynchronous = async;
}
根据调用关系:
step1: Handler构造函数中会去创建一个Looper对象。handler和Looper绑定,同时绑定Looper的messageQueue。
step2: Looper.myLooper()获取Looper.
step3: mLooper.mQueue 获取Looper的MessageQueue.
- 有参构造函数
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
Handler类在构造方法中,可指定Looper,Callback回调方法以及消息的处理方式(同步或异步),对于无参的handler,默认是当前线程的Looper.
mainHandler = new Handler() 等价于 new Handler（Looper.myLooper()）
Looper.myLooper()：获取当前进程的looper对象。详见下文.
1.2 Handler send message
call laddder:
sendEmptyMessage
--sendEmptyMessageDelayed
----sendMessageDelayed
------sendMessageAtTime
--------enqueueMessage
/////////////////////////////////////////////////////////////////////////
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
......
return enqueueMessage(queue, msg, uptimeMillis);
}
// 最后调用此方法添加到消息队列中
private boolean enqueueMessage(MessageQueue queue, Message msg,long uptimeMillis) {
msg.target = this;// 设置发送目标对象是Handler本身
......
return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息队列中
}
step1: Message.obtain
step2：enqueueMessage(queue, msg, uptimeMillis)
step3: msg.target = this;// 设置发送目标对象是Handler本身
return queue.enqueueMessage(msg, uptimeMillis);// 添加到消息队列中
1.3 消息处理
case1： handleMessage(msg);
是派生一个Hanlder子类并重写其handleMessage方法来处理具体的消息。
发送发是sendMessage.
case 2：handleCallback & mCallback.handleMessage(msg)
用callback来创建一个Handler的实例而无需派生Handler的子类。而Callback给我们提供了另外一种方式，那就是当我们不想派生子类的时候，可以通过Callback来实现.
call ladder:
post
--sendMessageDelayed
----getPostMessage
------m.callback = r//Runnable对象
--------new Handler(callback)
Message的callback是什么？其实就是一个Runnable对象，实际上就是Handler的post方法所传递的Runnable参数
private static void handleCallback(Message message) {
message.callback.run();
}
发送方：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
最后要注意的是写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop()才会中止，其后的代码才能得以运行.
1.4 异常处理
内存泄漏
//检查Handler是否是static的;如果不是的,那么有可能导致内存泄露
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());
}
}
小结：handler类：1) init 绑定looper，queue; 2) send msg 3) handle msg .
handler模型是以消息为中心，将消息放入主线程，消息绑定了handler对象，进而调用了handler执行函数。实现了对象，消息和函数绑定.
handler.sendmessage(msg)--msg.target.handlemsg(msg).
改写成以对象为中心的实现call ladder:Looper.enqueuemessage(handler)---handler.handlemessage(handler.msg).
2 Looper类
looper类：1） create queue 2) 循环读取 3） 分发
looper是两个线程，一个线程send message放入msg,一个线程epoll_wait 获取消息.
Looper.loop()循环取Message中的消息，回调msg.target.dispatchMessage(msg)。
Handler sendMessage 调用enqueueMessage,enqueueMessage第一行msg.target = this;这个this是什么呢？这个this在handler方法中自然是handler本身了,所以msg.target.dispatchMessage(msg);可以找到正确的handler,消息分开不会出错.
2.1 创建MessageQueue
//Looper类的构造方法创建了消息队列MessageQueue对象
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}
一个线程一个Looper一个MessageQueue.
2.2 获取Looper对象
通过ThreadLocal获取Looper对象
//handler调用的获取Looper对象的方法。实际是在ThreadLocal中获取。
public static Looper myLooper() {
return sThreadLocal.get();
}
2.3 Looper 主循环
Looper 读取message & 分发message
//looper中最重要的方法loop()，该方法是个死循环，会不断去消息队列MessageQueue中获取消息，
//然后调dispatchMessage(msg)方法去执行
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
//进入loop的主循环方法
for (;;) {
Message msg = queue.next(); // might block
......
//msg.target is handler；分发消息
msg.target.dispatchMessage(msg);
msg.recycle();
}
}
- Message msg= queue.next() ; 读取MessageQueue的下一条Message；
- msg.target.dispatchMessage(msg);把Message分发给相应的target；
next源码分析，参见MessageQueue类分析
下面是dispatchMessage分析
// 在looper类中的loop()方法内部调用的方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
分发给handleMessage 和handleCallback 处理.
2.4 子线程创建Looper（扩展）
如果子线程中使用Looper.prepare()和Looper.loop()创建了消息队列,就可以让消息处理在该线程中完成.
Looper.prepare() 通过map ThreadLocal绑定线程和新建的Looper(包含MessageQueue).判断looper在哪个线程内运行。
Looper.loop()不断地从当前线程对应Looper的MessageQueue中取出消息进行处理.
//perpare()方法，用来初始化一个Looper对象
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
......
sThreadLocal.set(new Looper(quitAllowed));
}
在非主线程中直接new Handler() 会报如下的错误: Can't create handler inside thread that has not called Looper.prepare() 原因是非主线程中默认没有创建Looper对象，需要先调用Looper.prepare()启用Looper，然后再调用Looper.loop()。
子线程自己创建Looper
class childThread extends Thread{
public Handler mHandler;
@Override
public void run() {
//子线程中必须先创建Looper
Looper.prepare();
mHandler =new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//处理消息
}
};
//启动looper循环
Looper.loop();
}
}
2.5 ThreadLocal
ThreadLocal机制：通常的全局变量，各个子线程是共享的。ThreadLocal变量特殊性是,它是global变量，但是每个子线程的ThreadLocal值是私有的.
原理是内部有个map管理每个线程和对应的变量.感兴趣的同学可以在网上搜显示源码.
ThreadLocal和线程局部变量又什么区别?线程局部变量完全可以替代ThreadLocal,但是ThreadLocal使用简单,java采用局部变量的方法比较少.两者的关系钱存在自己家和银行,实际是一样. Threadlocal 可以使一个Looper类统一管理所有线程的looper.
ThreadLocal与局部变量 ThreadLocal与局部变量_Jack Cheung-CSDN博客
3 MessageQueue类
线程同步在messageQueue的native层实现.
消息的循环，发送和处理
1） 生产者线程和消费者线程同步:
如果messageQueue为空: messageQueued.next 通过epoll监听messagequeue绑定的文件fd,实现读写同步.
如果messageQueue不为空: 生产者线程写，消费者线程读
nativePollOnce 阻塞，nativeWake 唤醒
//MessageQueue.java
boolean enqueueMessage(Message msg, long when) {
//...
synchronized (this) {
boolean needWake;
Message p = mMessages;
//如果处于阻塞状态，并且链表头部是一个同步屏障,并且插入消息是最早的异步消息,需要唤醒
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
//下面是一个链表的插入操作,将消息按时间顺序插入到mMessages中
for (;;) {
prev = p;
p = p.next；
//如果在找到插入位置之前，发现了异步消息的存在，不需要唤醒
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
//nativeWake方法会唤醒当前线程的MessageQueue
if (needWake) {
nativeWake(mPtr);
}
}
next() :提取下一条message.在这里messagequeue 阻塞. epoll 监听与messagequeue绑定的文件fd，详见：玩Android必看：从源码角度看Handler - 哔哩哔哩
Message next() {
final long ptr = mPtr;
......
for (;;) {
//阻塞操作，当等待nextPollTimeoutMillis时长，或者消息队列被唤醒，都会返回
nativePollOnce(ptr, nextPollTimeoutMillis);
......
}
}
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
jint ptr, jint timeoutMillis) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
nativeMessageQueue->pollOnce(timeoutMillis);
}
void NativeMessageQueue::pollOnce(int timeoutMillis) {
mLooper->pollOnce(timeoutMillis);
}
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
result = pollInner(timeoutMillis);
}
int Looper::pollInner(int timeoutMillis) {
......
struct epoll_event eventItems[EPOLL_MAX_EVENTS];
int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
for (int i = 0; i < eventCount; i++) {
int fd = eventItems[i].data.fd;
uint32_t epollEvents = eventItems[i].events;
if (fd == mWakeReadPipeFd) {
if (epollEvents & EPOLLIN) {
awoken();
}
}
}
void Looper::awoken() {
......
char buffer[16];
ssize_t nRead;
do {
nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
} while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
}
2） 多个生产者线程同时写：使用messageQueued.enqueueMessage中的锁同步.
messageQueue 从java-jni-native c++流程，参见：Android消息机制2-Handler(Native层) - Gityuan博客 | 袁辉辉的技术博客
4 Message.java源码：
读写Parcel数据
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();
}
public void writeToParcel(Parcel dest, int flags)
{
Parcelable p = (Parcelable)obj;
dest.writeInt(1);
dest.writeParcelable(p, flags);
......
}
QA:
- 主线程中的looper是一直轮询吗？
不是。如果MessageQueue没有消息时，就会阻塞在loop的queue.next()方法里. 这时候主线程会释放CPU资源进入休眠状态，直到有下个消息进来时候就会唤醒主线程. 使用Linux pipe/epoll机制，通过往pipe管道写端写入数据来唤醒主线程工作。原理类似于I/O,读写是堵塞的，不占用CPU资源。 \ - handler中发送消息线程安全吗？
线程安全。因为使用lock进行了线程同步.
MessageQueue中插入消息enqueueMessage方法以及取消息next都是线程安全的，都使用了synchronized进行加锁.
小结：
Handler源码：主要是绑定looper,sendmessage,handlemessage.
Looper源码： 主要是prepare-->Loop { queue.next;msg.target.dispatchMessage(msg); -->sThreadLocal.set(new Looper)}
Messagequeue.java源码：
Message next() {
nativePollOnce//epoll wait
}
enqueueMessage {
nativeWake //epoll wake
}
Message.java源码
readFromParcel,writeToParcel
附录源码：Handler.java, Looper.java , Message.java,MessageQueue.java
类似文章: Android的消息机制(java层) Android的消息机制(java层) - 简书
Android消息机制（native层） Android消息机制（native层） - 简书
