handler机制的源码分析和理解
这里写自定义目录标题
- 学习handler机制
-
- 1、创建线程消息队列
- **2、线程消息的循环过程**
- **3、线程的消息发送**
- **4、线程消息处理过程**
学习handler机制
首先举例handler的简单使用：
线程1
Runnable runnable1 = new Runnable() {
@Override
public void run() {
Looper.prepare(); //创建Looper 、MessageQueue实例化对象
handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.e("Data", "handleMessage: " + msg.obj.toString());
}
};
Looper.loop();// 进入loop循环
}
};
线程2
Runnable runnable2 = new Runnable() {
@Override
public void run() {
Message message = handler.obtainMessage();
message.obj = "你好啊，线程一";
handler.sendMessage(message);
}
线程二中使用的 handler 是线程一中创建的 handler
线程一中使用的looper方法
Looper.prepare(); 将当前线程初始化为 消息线程
Looper.loop(); 在此线程中运行 消息队列
######################################################################################
在学习handler机制中我们必须了解其中主要的四个类的作用
1 、Looper 类是用来创建消息队列的。
2 、MessageQueue 类是用来描述消息队列的。
3、Message 类是用来描述发送的消息。
4、Handler 类是用来发送和接受消息。
1、创建线程消息队列
android中应用线程的消息队列MessageQueue是由Looper类调用prepareMainLooper() 或 prepare() 来创建。这两者之间的差别在于prepareMainLooper应用于主线程创建消息队列, prepare() 应用于子线程创建消息队列。
1.1 创建Looper 对象，然后在Looper对象的构造函数中创建MessageQueue的对象。
frameworks/base/core/java/android/os/Looper.java
public final class Looper {
.......
static final ThreadLocal sThreadLocal = new ThreadLocal(); // 用来保存Looper的实列化对象。
final MessageQueue mQueue; //描述消息队列
private static Looper sMainLooper; // 主线程的Looper 对象
.......
private Looper(boolean quitAllowed) { // 参数判断是否允许推出，主线程不允许退出，子线程允许退出。
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
//子线程调用创建MessagerQueue： prepare() -> prepare(boolean quitAllowed) -> Looper(boolean quitAllowed)
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) { //从类似hashmap的sThreadLocal中获得Looper的实列化对象
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed)); //如果之前没有创建过，就创建一个新的Looper对象并set进去。
}
// 主线程调用创建MessagerQueue: prepareMainLooper() -> prepare(boolean quitAllowed) -> Looper(boolean quitAllowed) -> myLooper()
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
}
1.2 引入MessageQueue，然后在MessageQueue的对象中记录C++层的NativeMessageQueue对象的地址。
frameworks/base/core/java/android/os/MessageQueue.java
// mPtr 用来记录C++层NativeMessageQueue对象的地址。
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit(); // 创建C++层NativeMessageQueue对象
}
1.3 返回NativeMessageQueue对象的地址
frameworks/base/core/jni/android_os_MessageQueue.cpp
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
if (!nativeMessageQueue) {
jniThrowRuntimeException(env, "Unable to allocate native queue");
return 0;
}
nativeMessageQueue->incStrong(env);
return reinterpret_cast(nativeMessageQueue);
}
1.4 在NativeMessageQueue的构造函数中实列化Native Looper
frameworks/base/core/jni/android_os_MessageQueue.cpp
// getForThread() 用来判断是否已经创建过一个native 的 looper。 setForThread() 将new的Looper对象和当前进程绑定
NativeMessageQueue::NativeMessageQueue() :
mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
mLooper = Looper::getForThread();
if (mLooper == NULL) {
mLooper = new Looper(false);
Looper::setForThread(mLooper);
}
}
2、线程消息的循环过程
创建了Looper、MessageQueue之后，就开始进入Loop循环。
2.1 调用loop方法
frameworks/base/core/java/android/os/Looper.java
// 在loop()中我们首先会get到当前的looper的实例化对象， 之后再找到这个looper对应的messageQueue对象。调用next（）进入messageQueue类
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;
...........
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
.........
}
2.2 进入MessageQueue 类
frameworks/base/core/java/android/os/MessageQueue.java
// 调用 nativePollOnce（）不断的检查当前线程的消息队列中是否有新的消息需要处理。
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0; // 进入睡眠的等待时间。=0 ，即使没有消息进入消息队列，也不能进入睡眠。= -1 当前没有新的消息，线程就需要无限的处于睡眠等待状态。 > 0 当前线程在没有新的消息的情况下，进入睡眠状态等待的时间。
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
..........
}
...........
}
**2.3 从next() -> nativePollOnce()
frameworks/base/core/jni/android_os_MessageQueue.cpp
**
其实在这里直接就是从nativePollOnce() -> pollOnce()
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
jlong ptr, jint timeoutMillis) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast(ptr);
nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}
而在 pollOnce()又会调到 native looper的 pollOnce
void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
mPollEnv = env;
mPollObj = pollObj;
mLooper->pollOnce(timeoutMillis);
mPollObj = NULL;
mPollEnv = NULL;
if (mExceptionObj) {
env->Throw(mExceptionObj);
env->DeleteLocalRef(mExceptionObj);
mExceptionObj = NULL;
}
}
2.4 从nativeMessageQueue::pollOnce -> Looper::pollOnce()
system/core/libutils/Looper.cpp
这里由于Looper::pollOnce()的代码理解难度有点大，我们这就顺带提一下它的作用有兴趣的可以查看文章 https://www.jianshu.com/p/4fac27284475
Looper::pollOnce() 的作用就是睡眠与唤醒的线程的作用。
3、线程的消息发送
3.1 Handler主要就是用来向一个线程的消息队列发送消息
frameworks/base/core/java/android/os/Handler.java
public Handler(Callback callback, boolean async) {
..........
mLooper = Looper.myLooper();
mQueue = mLooper.mQueue;
mCallback = callback;
.........
}
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public void handlerMessage(Message msg) {
}
这里我们可以看到一个Handler类中有Looper 、MessageQueue成员变量。Handler 对象使用成员函数sendMessage() 向成员变量mQueue 发送消息。而成员函数handlerMessage()用来接收处理消息，他是与mLooper所关联的线程中调用的。
3.2 我们先从sendMessage() 发送一个消息开始
frameworks/base/core/java/android/os/Handler.java
从sendMessage()最后会调到sendMessageAtTime() 然后又到MesssageQueue的enqueueMessage（）
这里的参数 msg 描述的是即将发送的消息，uptimeMillis则是用来描述发送的消息需要处理的时间。
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this; // 将当前正在处理的一个Handler 对象。赋值给target
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
3.3 在MessageQueue中equeueMessage会对要发送的消息msg进行处理，会根据这个消息需要处理的等待时间将msg插入到合适的位置。这里不是直接的放入到messageQueue 中而是插入到Message的next指针后面
boolean enqueueMessage(Message msg, long when) {
.......
msg.markInUse();
msg.when = when; //msg中记录等待的处理时间
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;
}
// 调到native 从 nativeWake() -> wake()
static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast(ptr);
nativeMessageQueue->wake();
}
**3.4 最后从NativeMessageQueue又会调到Looper的wake()
system/core/libutils/Looper.cpp
**
void Looper::wake() {
#if DEBUG_POLL_AND_WAKE
ALOGD("%p ~ wake", this);
#endif
uint64_t inc = 1;
ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &inc, sizeof(uint64_t))); // 这里会通过管道文件描述符mWakeEventFd，向管道写一个新的数据，线程就被唤醒了。
if (nWrite != sizeof(uint64_t)) {
if (errno != EAGAIN) {
LOG_ALWAYS_FATAL("Could not write wake signal to fd %d: %s",
mWakeEventFd, strerror(errno));
}
}
}
至此一个消息如何发送，如何插入到消息队列，之后唤醒线程就结束了，后面再继续分析如果接收处理一个消息。
4、线程消息处理过程
**4.1 **
持续更新。。。。。。