简介
最近各种事情，而且生病比较严重，有可能要做手术，人生中很灰色的一段日子，所以就没有写技术博客了，现在续上。
初步学Android开发的时候，我当时接触了Handler很懵逼的，比如访问网络，操作数据库直接写代码不好吗？为什么还要放入子线程，然后完了还用Handler通知到UI线程，当时想不通，后来陆陆续续的觉得理所应当，就应该那样，再后来就觉得耗时操作不能再主线程中，再后来看Android文档上写的那样就是那样，之后接触了系统，才明白。其实莫怕，我们经常说的UI线程，主线程，他们也只不过是一个特殊的死循环而已，也是代码，不是神物。所以从Handler开始剖析吧。
Android中线程是和做app开发童鞋密切相关的知识点，掌握或者了解Android中线程对我们做app或者做系统很有帮助，那我们就开始今天的Android线程之旅。
Handler
- 一个Thread对应一个Looper
- 一个Handler对应一个
Looper mLooper - 一个Looper对应一个
MessageQueue - 一个MessageQueue对应多个Message
- 每一个MessageQueue最多有一个Handler处理消息
所以我们看出来Handler可以在Thread中有多个存在多个存在。
Looper
我们知道Looper类是一个线程的消息循环处理器
1.Looper构造方法私有.
2.Looper对象每个线程只能有一个.
3.并且通过静态prepare方法创建.
4.保存在ThreadLocal<Looper> sThreadLocal中(是一个线程有关的键值对存取容器)
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
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));
}
我们下来看看Looper类的loop方法
public static void loop() {
final Looper me = myLooper();//得到当前线程的looper
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//从looper中拿出消息队列
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); //进行遍历消息队列
if (msg == null) {
return;
}
Printer logging = me.mLogging;
msg.target.dispatchMessage(msg);//拿到Handler进行分发事件
final long newIdent = Binder.clearCallingIdentity();
msg.recycleUnchecked();
}
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
loop()中就做了4个事情
1.得到当前线程的looper
2.从looper中拿出消息队列
3.进行遍历消息队列
4.拿到Handler进行分发事件
这里思考一个问题:既然知道ThreadLocal<Looper> sThreadLocal是一个拿取当前线程的Looper类,那么当前线程是在哪?
这里看下Handler的构造:
public Handler(Callback callback, boolean async) {
...
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
...
}
可以看出来我们一般使用在Activity中创建Handler然后发送消息,所以Handler中得到的也是Activity的线程.
问题来了:Activity的线程大家都说是UI线程,但是也没有人具体说怎么UI了,在哪里UI了,下面我就带大家溜溜源码.
具体我们看一看目标进程中的哪里创建了Activity对象
//ApplicationThread.java
public final void scheduleLaunchActivity(...) {
...
sendMessage(H.LAUNCH_ACTIVITY, r);
}
public void handleMessage(Message msg) {
switch (msg.what) {
case LAUNCH_ACTIVITY: {
...
handleLaunchActivity(r, null);
} break;
...
}
}
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
Activity a = performLaunchActivity(r, customIntent);
...
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
Activity activity = null;
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
//通过反射创建Activity
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
//下面就是调用各种Activity的生命周期回调方法
activity.attach(...);
mInstrumentation.callActivityOnCreate(activity, r.state);
activity.performStart();
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,r.persistentState);
mInstrumentation.callActivityOnPostCreate(activity, r.state,r.persistentState);
mInstrumentation.callActivityOnPostCreate(activity, r.state);
return activity;
}
上面过程我们看出来是ApplicationThread类sendMessage(H.LAUNCH_ACTIVITY,r);在handleMessage的分发事件中创建出来了Activity对象,所以这个问题归结于这个分发事件在那个进程的那个线程中跑.
来看,首先发给消息的Handler是在ActivityThread类中创建的H对象
private class H extends Handler {
public static final int LAUNCH_ACTIVITY = 100;
也就是说,在Activity中的Looper对象是在ActivityThread所在的线程中.
那我们就来看看ActivityThread在那个线程中,我们看看ActivityThread创建的main方法
public static void main(String[] args) {
...
Looper.prepareMainLooper();//创建属于此线程的Looper
ActivityThread thread = new ActivityThread();
thread.attach(false);
...
Looper.loop();
}
public static void prepareMainLooper() {
prepare(false);
...
}
private static void prepare(boolean quitAllowed) {
...
sThreadLocal.set(new Looper(quitAllowed));
}
到了这里我们惊喜的发现在ActivityThread的main()方法中创建了主线程的Looper,并且Activity和ActivityThread在同一个线程,即主线程
小结:
1.Looper类是Android中线程消息通信的重要类,扮演线程消息的处理器的角色
2.每个线程只能创建一个Looper对象
3.通过Looper.prepare()方法创建Looper对象,Looper.prepareMainLooper();创建主线程Looper对象
4.有了Looper对象用loop方法进入消息循环
5.loop方法不断从MessageQueue队列中拿出消息,然后分发给Handler的回调方法
6.一个Looper可以对应多个Handler对象
7.Looper方法在存取每个线程所属于的私有变量是通过ThreadLocal成员
8.在Activity中创建的Handler对象,中创建的Looper是和ActivityThread在一个线程中即主线程
思考?
我们既然在Handler中得到属于当前主线程的Looper了,并且得到属于当前线程的mQueue队列了,那么我们用这个消息队列做什么?如何才能给消息队列中发消息,这个消息队列又是在哪里创建的呢?
带着上述问题我们看看源码怎么说!
首先看Handler的sendMessage方法
//Handler.java通过handler.sendEmptyMessage(1);
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 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;//mQueue是什么时候有值的呢?
if (queue == null) {
RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");
...
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);//继续追
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);//好暂时到这里停止
}
上面我们一直在追Handler的发送消息源代码,最后发现调用的是MessageQueue queue的enqueueMessage方法将消息传递
这个时候我们注意几个问题:
1.msg类型是Message implements Parcelable {类型,说明可以跨进程
2.msg.target = this;//这里的msg.target就是当前Handler类
3.MessageQueue queue = mQueue;是在sendMessageAtTime方法中被赋值,问题是mQueue在什么时候被赋值呢?(看上节)
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) {
...
}
}
mLooper = Looper.myLooper();
...
mQueue = mLooper.mQueue;
...
}
所以在Handler的构造中mQueue被赋值,mLooper是主线程的Looper,主线程是在ActivityThread中创建的,当执行ActivityThread的main()方法的时候执行了Looper.prepareMainLooper();
public static void prepareMainLooper() {
prepare(false);//向下追
...
}
private static void prepare(boolean quitAllowed) {
...
sThreadLocal.set(new Looper(quitAllowed));//继续追Looper的构造
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);//创建消息队列
mThread = Thread.currentThread();
}
小结
Handler的构造得到属于当前线程的Looper,此Looper是主线程的Looper,主线程在ActivityThread中创建,在创建的时候调用Looper的构造方法,构造方法中创建了MessageQueue对象.
那么既然我们现在知道Handler.sendEmptyMessage()-->queue.enqueueMessage()其中queue是mQueue在ActivityThread调用prepareMainLooper的时候创建.那么我们具体看看queue.enqueueMessage()这个方法做了什么事情.
MessageQueue.java
boolean enqueueMessage(Message msg, long when){
...
synchronized (this) {
...
msg.when = when;
Message p = mMessages;//p指向消息队列的头部
boolean needWake;
if (p == null || when == 0 || when < p.when) {
msg.next = p;//没有消息,就将msg作为头部
mMessages = msg;
needWake = mBlocked;
} else {
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;
prev.next = msg;
}
if (needWake) {//需要唤醒,则唤醒线程
nativeWake(mPtr);
}
}
return true;
}
可以看出来这里面做的是链表的增删,将msg进行插入.队列为空的时候将msg作为头部.
所以有如下小结:
通过Handler发送消息,是就上就是把msg插入到MessageQueue队列中,进行判断看插入时候是不是需要唤醒线程.
引申问题!
既然知道了插入队列,不读取,插入也没有意义呀,那么在哪里读取呢?
我们通过上节知道,在loop()方法中有句代码Message msg = queue.next();,所以我们知道了是在Looper.loop()方法中调用queue.next()方法,但是我们并不知道next()怎么一个运作机理,现在我们就从MessageQueue的构造方法开始,分析一下MessageQueue如何拿出消息.
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();//好奇的宝宝怎么可能不追下去
}
//这里分享一个知识点,就是native开头的方法都是本地方法,本地方法命名规则是报名+类名字+方法名并且将所有.号替换成_
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();//创建native层的NativeMessageQueue我们继续追下去
...
nativeMessageQueue->incStrong(env);
return reinterpret_cast<jlong>(nativeMessageQueue);
}
NativeMessageQueue::NativeMessageQueue() :mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
mLooper = Looper::getForThread();
if (mLooper == NULL) {
mLooper = new Looper(false);//创建一个Looper对象
Looper::setForThread(mLooper);
}
}
这里得解释一下,要不然后面看着懵逼,为什么多了一个Looper对象,还怎么才native层,不是在java层吗?怎么跑的?
这里就要解释一下了,这个Looper和java层那个Looper并没有直接关系,netive的Looper也是实现了一套完整的消息机制,那么究竟这个Looper干了啥,我们继续追到Looper中.
Looper::Looper(bool allowNonCallbacks) :... {
mWakeEventFd = eventfd(0, EFD_NONBLOCK);//功能进程(线程)间的等待/通知(wait/notify) 机制.设置非阻塞
...
AutoMutex _l(mLock);
rebuildEpollLocked();//暂时没发现啥,继续看下去
}
这里要介绍一下eventfd函数,这个是Linux内核新增加的函数,实现了线程之间事件通知的方式
函数返回一个文件描述符，与打开的其他文件一样，可以进行读写操.
eventfd也可以放到监听队列中返回的fd可以进行如下操作：read、write、select(poll、epoll)、close.
eventfd的缓冲区大小是sizeof(uint64_t)也就是8字节，它是一个64位的计数器，写入递增计数器，读取将得到计数器的值，并且清零。
void Looper::rebuildEpollLocked() {
...
mEpollFd = epoll_create(EPOLL_SIZE_HINT);
...
struct epoll_event eventItem;
memset(& eventItem, 0, sizeof(epoll_event));
eventItem.events = EPOLLIN;
eventItem.data.fd = mWakeEventFd;//记录需要监听的fd就是上面mWakeEventFd = eventfd(0, EFD_NONBLOCK);
int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);//注册事件
for (size_t i = 0; i < mRequests.size(); i++) {
const Request& request = mRequests.valueAt(i);
struct epoll_event eventItem;
request.initEventItem(&eventItem);
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, request.fd, & eventItem);
...
}
}
小结上面这一丢丢:
也就是说,在MessageQueue构造中创建了native层的NativeMessageQueue,NativeMessageQueue创建导致了native层的Looper创建,底层的Looper创建进行操作就是利用内核函数eventfd实现一个8字节的缓冲区并且用epoll_ctl进行监听文件句柄
那么上面我们看完了MessageQueue的创建过程,但是我们还不知道创建了辣么多机制东东在哪里用咋整,下一步我们就开始分析MessageQueue拿数据的过程.
由于第一节我们已经说道,在Java层的Looper.loop()方法中是个死循环,死循环中调用MessageQueue中的next()方法.那么我们就看看MessageQueue中的next方法
Message next() {
...
for (;;) {
...
nativePollOnce(ptr, nextPollTimeoutMillis);//注意这个本地方法,ptr是NativeMessageQueue地址
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;//指向消息头
...
if (msg != null) {//找到第一条消息
if (now < msg.when) {//消息没有到达时间,计算出要需要多少时间能到达这个消息
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
mBlocked = false;//取消阻塞
//下面是断开链表一个节点
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
return msg;返回消息
}
} else {
nextPollTimeoutMillis = -1;
}
if (mQuitting) {//当在quit函数中设置mQuitting=true,表明退出,则执行下面
dispose();//销毁native对象
return null;
}
...
}
...
}
}
上面我们看到了将消息从头部开始一条一条拿出,并且如果消息不为空,那就返回msg,当退出的时候调用dispose()销毁native中的对象.
我们好奇了,那nativie中刚才的代码一会eventfd的一会epoll_ctl的,在next方法中没体现到他们的用处呀.稍安勿躁,看见next方法中还有一个nativePollOnce函数没有介绍吗?下面就来分析这个函数究竟做了什么事情.
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
jlong ptr, jint timeoutMillis) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
nativeMessageQueue->pollOnce(env, obj, timeoutMillis);//继续追
}
void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
mPollEnv = env;
mPollObj = pollObj;
mLooper->pollOnce(timeoutMillis);//调用了native层mLooper的pollOnce方法.继续追
mPollObj = NULL;
mPollEnv = NULL;
if (mExceptionObj) {
env->Throw(mExceptionObj);
env->DeleteLocalRef(mExceptionObj);
mExceptionObj = NULL;
}
}
inline int pollOnce(int timeoutMillis) {
return pollOnce(timeoutMillis, NULL, NULL, NULL);//继续追
}
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
int result = 0;
for (;;) {
...
result = pollInner(timeoutMillis);//继续追
}
}
int Looper::pollInner(int timeoutMillis){
...
//mEpollFd就是我们前面epoll_ctl注册的mEpollFd
int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
...
return result;
}
小结:
我们从MessageQueue的next()方法入手,一步步最后追寻到native层的 Looper::pollInner方法的调用,也就是说,我们在next方法内部大部分时间都是在这里阻塞,但是此时阻塞并不消耗cpu资源,所以如果向eventfd写入数据,epoll_wait就会返回,阻塞结束,就可以在java层拿数据了.
大结:
这个时候我们已经分析的很清楚了,那个线程那个进程做了什么事情,如果还不了解,在继续多读几遍,相信读者一定会有不一样的感受.最后我们在大概说说流程.
在ActivityThread.main()方法被调用的时候就创建了主线程,主线程是什么,主线程是一个消息队列+不断循环处理消息.
Handler的创建,创建了java层的Looper对象,Looper创建了MessageQueue对象,MessageQueue创建了native层的NativeMessageQueue对象,NativeMessageQueue对象创建了native的Looper对象,和使用epoll机制监听eventfd返回的句柄(进行线程通信),然后就是循环,java层的loop中调用MessageQueue的next()方法,next()方法中做了两件大事情,一个是调用到native中进行阻塞,一个是从头开始读取消息队列中的msg进行分离返回.
当我们使用Handler中的sendXXX方法发送消息的时候,最终调用的是MessageQueue queue.enqueueMessage()方法将一个msg插入到消息队列中.
