Handler机制源码分析

最新推荐文章于 2021-09-28 20:07:55 发布

fdsafwagdagadg6576

最新推荐文章于 2021-09-28 20:07:55 发布

阅读量258

点赞数

分类专栏： Android 文章标签： 1024程序员节

本文链接：https://blog.csdn.net/fdsafwagdagadg6576/article/details/111300450

版权

Android 专栏收录该内容

39 篇文章 8 订阅

订阅专栏

前言

Handler使用，请参见：Handler总结和补充_fdsafwagdagadg6576的专栏-CSDN博客

正文

Hander源码机制包括四部分源码:
Handler源码,Looper源码Message源码,Messagequeue源码.
分成java层和native层.
消息流程:handler---messageQueue---Looper---hander,消息发送---消息接收---消息分发--消息处理.
类图关系

handler_java

1 Handler类

1.1 Handler 构造函数初始化
1) 无参数构造函数

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.

2) 有参构造函数

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:

1) 主线程中的looper是一直轮询吗？
不是。如果MessageQueue没有消息时，就会阻塞在loop的queue.next()方法里. 这时候主线程会释放CPU资源进入休眠状态，直到有下个消息进来时候就会唤醒主线程. 使用Linux pipe/epoll机制，通过往pipe管道写端写入数据来唤醒主线程工作.原理类似于I/O,读写是堵塞的，不占用CPU资源.

2) 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层） - 简书