Android应用程序消息循环源码分析

最新推荐文章于 2021-01-28 20:32:21 发布
最新推荐文章于 2021-01-28 20:32:21 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： Android Deeping

消息都是存放在一个消息队列中去，而消息循环线程就是围绕这个消息队列进入一个无限循环的，直到线程退出。如果队列中有消息，消息循环线程就会把它取出来，并分发给相应的Handler进行处理；如果队列中没有消息，消息循环线程就会进入空闲等待状态，等待下一个消息的到来。在编写Android应用程序时，当程序执行的任务比较繁重时，为了不阻塞UI主线程而导致ANR的发生，我们通常的做法的创建一个子线程来完成特定的任务。在创建子线程时，有两种选择，一种通过创建Thread对象来创建一个无消息循环的子线程；还有一种就是创建一个带有消息循环的子线程，而创建带有消息循环的子线程由于两种实现方法，一种是直接利用Android给我们封装好的HandlerThread类来直接生成一个带有消息循环的线程对象，另一种方法是在实现线程的run()方法内使用以下方式启动一个消息循环：

[cpp] view plain copy print ?
  1. @Override  
  2. public void run() {  
  3.     // TODO Auto-generated method stub  
  4.     Looper.prepare();  
  5.     ...  
  6.       
  7.     Looper.loop();  
  8. }  
@Override
public void run() {
	// TODO Auto-generated method stub
	Looper.prepare();
	...
	
	Looper.loop();
}
关于消息循环的创建及启动过程在稍后进行分析。当启动了一个带消息循环的子线程时，就可以往这个子线程中发送消息，那么消息是如何发送到子线程的消息队列中的呢？这就需要使用Handler对象来完成这一艰巨的任务。

Hanlder对象的构造过程


Handler对象的构造方法有三种：

1. 使用当前线程的Looper来构造Handler对象，如果当前线程没有消息循环，则当前Handler不能处理消息

[cpp] view plain copy print ?
  1. public Handler() {  
  2.     if (FIND_POTENTIAL_LEAKS) {  
  3.         final Class<? extends Handler> klass = getClass();  
  4.         if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
  5.                 (klass.getModifiers() & Modifier.STATIC) == 0) {  
  6.             Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
  7.                 klass.getCanonicalName());  
  8.         }  
  9.     }  
  10.     //使用当前线程的Looper  
  11.     mLooper = Looper.myLooper();  
  12.     if (mLooper == null) {  
  13.         throw new RuntimeException(  
  14.             "Can't create handler inside thread that has not called Looper.prepare()");  
  15.     }  
  16.     //使用当前线程的消息队列  
  17.     mQueue = mLooper.mQueue;  
  18.     mCallback = null;  
  19. }  
public Handler() {
	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());
		}
	}
	//使用当前线程的Looper
	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 = null;
}
获取当前线程的Looper对象过程：
[cpp] view plain copy print ?
  1. public static Looper myLooper() {  
  2.     //从线程本地存储对象中取出当前线程的Looper对象  
  3.     return sThreadLocal.get();  
  4. }  
public static Looper myLooper() {
	//从线程本地存储对象中取出当前线程的Looper对象
	return sThreadLocal.get();
}
2. 使用指定的Looper对象来构造Handler对象
[cpp] view plain copy print ?
  1. public Handler(Looper looper) {  
  2.     mLooper = looper;  
  3.     mQueue = looper.mQueue;  
  4.     mCallback = null;  
  5. }  
public Handler(Looper looper) {
	mLooper = looper;
	mQueue = looper.mQueue;
	mCallback = null;
}
这种构造方法就是利用已有的Looper对象来构造对应的Handler对象，因此在构造Handler对象之前必须首先构造一个Looper对象。

frameworks\base\core\java\android\os\Looper.java

[cpp] view plain copy print ?
  1. public static void prepare() {  
  2.     prepare(true);  
  3. }  
public static void prepare() {
	prepare(true);
}
使用另一个prepare方法来构造Looper对象，参数true表示该消息循环可以退出

[cpp] view plain copy print ?
  1. private static void prepare(boolean quitAllowed) {  
  2.     //首先从线程本地存储中查找是否已经存在对应的Looper对象了，  
  3.     if (sThreadLocal.get() != null) {  
  4.         throw new RuntimeException("Only one Looper may be created per thread");  
  5.     }  
  6.     //创建一个新的Looper对象，并保存到线程存储对象中  
  7.     sThreadLocal.set(new Looper(quitAllowed));  
  8. }  
private static void prepare(boolean quitAllowed) {
	//首先从线程本地存储中查找是否已经存在对应的Looper对象了，
	if (sThreadLocal.get() != null) {
		throw new RuntimeException("Only one Looper may be created per thread");
	}
	//创建一个新的Looper对象，并保存到线程存储对象中
	sThreadLocal.set(new Looper(quitAllowed));
}
该函数调用了Looper的构造函数来构造一个Looper对象

[cpp] view plain copy print ?
  1. private Looper(boolean quitAllowed) {  
  2.     mQueue = new MessageQueue(quitAllowed);  
  3.     mRun = true;  
  4.     mThread = Thread.currentThread();  
  5. }  
private Looper(boolean quitAllowed) {
	mQueue = new MessageQueue(quitAllowed);
	mRun = true;
	mThread = Thread.currentThread();
}
在构造Looper对象时，自动创建一个Java层的消息循环队列MessageQueue对象。消息队列构造过程：

[cpp] view plain copy print ?
  1. MessageQueue(boolean quitAllowed) {  
  2.     mQuitAllowed = quitAllowed;  
  3.     nativeInit();  
  4. }  
MessageQueue(boolean quitAllowed) {
	mQuitAllowed = quitAllowed;
	nativeInit();
}

在构造Java层的消息队列MessageQueue对象时，会通过JNI进入C++层，在C++层构造一个与Java层消息队列相对应的消息队列对象

frameworks\base\core\jni\android_os_MessageQueue.cpp 
[cpp] view plain copy print ?
  1. static void android_os_MessageQueue_nativeInit(JNIEnv* env, jobject obj) {  
  2.     //在C++层创建NativeMessageQueue对象  
  3.     NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();  
  4.     if (!nativeMessageQueue) {  
  5.         jniThrowRuntimeException(env, "Unable to allocate native queue");  
  6.         return;  
  7.     }  
  8.     nativeMessageQueue->incStrong(env);  
  9.     //将C++的NativeMessageQueue对象指针保存到Java的MessageQueue对象成员变量mPtr中  
  10.     android_os_MessageQueue_setNativeMessageQueue(env, obj, nativeMessageQueue);  
  11. }  
static void android_os_MessageQueue_nativeInit(JNIEnv* env, jobject obj) {
	//在C++层创建NativeMessageQueue对象
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
    if (!nativeMessageQueue) {
        jniThrowRuntimeException(env, "Unable to allocate native queue");
        return;
    }
    nativeMessageQueue->incStrong(env);
	//将C++的NativeMessageQueue对象指针保存到Java的MessageQueue对象成员变量mPtr中
    android_os_MessageQueue_setNativeMessageQueue(env, obj, nativeMessageQueue);
}

在C++层创建了一个NativeMessageQueue对象，NativeMessageQueue的构造过程如下：

[cpp] view plain copy print ?
  1. NativeMessageQueue::NativeMessageQueue() : mInCallback(false), mExceptionObj(NULL) {  
  2.     mLooper = Looper::getForThread();  
  3.     if (mLooper == NULL) {  
  4.         mLooper = new Looper(false);  
  5.         Looper::setForThread(mLooper);  
  6.     }  
  7. }  
NativeMessageQueue::NativeMessageQueue() : mInCallback(false), mExceptionObj(NULL) {
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);
        Looper::setForThread(mLooper);
    }
}
这里又创建了一个C++的Looper对象，下图描述了这些对象之间的关系：


C++层的Looper对象构造过程：

[cpp] view plain copy print ?
  1. Looper::Looper(bool allowNonCallbacks) :  
  2.         mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),  
  3.         mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {  
  4.     int wakeFds[2];  
  5.     //通过pipe系统调用来创建了一个管道了  
  6.     int result = pipe(wakeFds);  
  7.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);  
  8.   
  9.     mWakeReadPipeFd = wakeFds[0];  
  10.     mWakeWritePipeFd = wakeFds[1];  
  11.   
  12.     result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);  
  13.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",errno);  
  14.   
  15.     result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);  
  16.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",errno);  
  17.   
  18.     // 通过epoll_create来创建一个epoll专用的文件描述符  
  19.     mEpollFd = epoll_create(EPOLL_SIZE_HINT);  
  20.     LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);  
  21.   
  22.     struct epoll_event eventItem;  
  23.     memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union  
  24.     eventItem.events = EPOLLIN;  
  25.     eventItem.data.fd = mWakeReadPipeFd;  
  26.     //通过epoll_ctl函数来告诉epoll要监控相应的文件描述符  
  27.     result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, & eventItem);  
  28.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",errno);  
  29. }  
Looper::Looper(bool allowNonCallbacks) :
        mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
        mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
    int wakeFds[2];
	//通过pipe系统调用来创建了一个管道了
    int result = pipe(wakeFds);
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);

    mWakeReadPipeFd = wakeFds[0];
    mWakeWritePipeFd = wakeFds[1];

    result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",errno);

    result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",errno);

    // 通过epoll_create来创建一个epoll专用的文件描述符
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);

    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
    eventItem.events = EPOLLIN;
    eventItem.data.fd = mWakeReadPipeFd;
	//通过epoll_ctl函数来告诉epoll要监控相应的文件描述符
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, & eventItem);
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",errno);
}
构造Looper对象时，创建了无名管道，并创建了epoll实例，同时将管道的读端添加到epoll中监听。这里就是告诉mEpollFd，它要监控mWakeReadPipeFd文件描述符的EPOLLIN事件，即当管道中有内容可读时，就唤醒当前正在等待管道中的内容的线程。管道就是一个文件，在管道的两端，分别是两个打开文件文件描述符，这两个打开文件描述符都是对应同一个文件，其中一个是用来读的，别一个是用来写的，一般的使用方式就是，一个线程通过读文件描述符中来读管道的内容，当管道没有内容时，这个线程就会进入睡眠等待状态，而另外一个线程通过写文件描述符来向管道中写入内容，写入内容的时候，如果另一端正有线程正在等待管道中的内容，那么这个线程就会被唤醒。这个等待和唤醒的操作就是借助Linux系统中的epoll机制。  Linux系统中的epoll机制为处理大批量句柄而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本。


3. 使用指定的消息处理Callback对象来构造Hander对象
[cpp] view plain copy print ?
  1. public Handler(Callback callback) {  
  2.     if (FIND_POTENTIAL_LEAKS) {  
  3.         final Class<? extends Handler> klass = getClass();  
  4.         if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
  5.                 (klass.getModifiers() & Modifier.STATIC) == 0) {  
  6.             Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
  7.                 klass.getCanonicalName());  
  8.         }  
  9.     }  
  10.     //使用当前线程的Looper对象  
  11.     mLooper = Looper.myLooper();  
  12.     if (mLooper == null) {  
  13.         throw new RuntimeException(  
  14.             "Can't create handler inside thread that has not called Looper.prepare()");  
  15.     }  
  16.     mQueue = mLooper.mQueue;  
  17.     mCallback = callback;  
  18. }  
public Handler(Callback callback) {
	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());
		}
	}
	//使用当前线程的Looper对象
	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;
}
通过以上三种构造方式就可以为带有消息循环的线程创建一个消息发送工具Handler对象，在构造Handler对象过程中：

在Java层，创建了一个Looper对象，这个Looper对象是用来进入消息循环的，它的内部有一个消息队列MessageQueue对象mQueue；

在JNI层，创建了一个NativeMessageQueue对象，这个NativeMessageQueue对象保存在Java层的消息队列对象mQueue的成员变量mPtr中；

在C++层，创建了一个Looper对象，保存在JNI层的NativeMessageQueue对象的成员变量mLooper中，当Java层的消息队列中没有消息或者C++层没有消息请求，并且被监控的IO接口上没有事件发生，消息循环线程进入等待状态，否则，就唤醒Android应用程序的主线程来处理这个消息。

Java消息发送过程


使用Handler对象的sendMessage函数向线程的消息队列发送一个消息
[cpp] view plain copy print ?
  1. public final boolean sendMessage(Message msg)  
  2. {  
  3.     return sendMessageDelayed(msg, 0);  
  4. }  
public final boolean sendMessage(Message msg)
{
	return sendMessageDelayed(msg, 0);
}
函数sendMessageDelayed用于延迟发送一个消息，该函数的第二个参数用于指定延时时间，通过sendMessage函数发送的消息的处理时间默认就为当前时间，即表示要马上处理，因此，从sendMessage函数中调用sendMessageDelayed函数，传入的时间参数为0，表示这个消息不要延时处理。
[cpp] view plain copy print ?
  1. public final boolean sendMessageDelayed(Message msg, long delayMillis)  
  2. {  
  3.     if (delayMillis < 0) {  
  4.         delayMillis = 0;  
  5.     }  
  6.     return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
  7. }  
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
	if (delayMillis < 0) {
		delayMillis = 0;
	}
	return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
sendMessageAtTime函数用于在指定时间发送一个消息，通过指定的延时时间来计算出消息发送的时间，先获得当前时间，然后加上消息要延时处理的时间，即得到这个处理这个消息的绝对时间，然后调用sendMessageAtTime函数来把消息加入到应用程序的消息队列中去。
[cpp] view plain copy print ?
  1. public boolean sendMessageAtTime(Message msg, long uptimeMillis)  
  2. {  
  3.     boolean sent = false;  
  4.     MessageQueue queue = mQueue;  
  5.     if (queue != null) {  
  6.         //设置消息处理的目标Handler对象为当前发送消息的Handler对象  
  7.         msg.target = this;  
  8.         //将消息压入消息队列  
  9.         sent = queue.enqueueMessage(msg, uptimeMillis);  
  10.     }  
  11.     else {  
  12.         RuntimeException e = new RuntimeException(  
  13.             this + " sendMessageAtTime() called with no mQueue");  
  14.         Log.w("Looper", e.getMessage(), e);  
  15.     }  
  16.     return sent;  
  17. }  
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
	boolean sent = false;
	MessageQueue queue = mQueue;
	if (queue != null) {
		//设置消息处理的目标Handler对象为当前发送消息的Handler对象
		msg.target = this;
		//将消息压入消息队列
		sent = queue.enqueueMessage(msg, uptimeMillis);
	}
	else {
		RuntimeException e = new RuntimeException(
			this + " sendMessageAtTime() called with no mQueue");
		Log.w("Looper", e.getMessage(), e);
	}
	return sent;
}
函数首先设置这个消息的目标对象target，即处理这个消息的目标Handler对象：
[cpp] view plain copy print ?
  1. msg.target = this;  
msg.target = this;
然后调用消息队列对象MessageQueue的enqueueMessage方法来将一个消息压入到消息队列中。
frameworks\base\core\java\android\os\MessageQueue.java
[cpp] view plain copy print ?
  1. final boolean enqueueMessage(Message msg, long when) {  
  2.     if (msg.isInUse()) {  
  3.         throw new AndroidRuntimeException(msg + " This message is already in use.");  
  4.     }  
  5.     if (msg.target == null) {  
  6.         throw new AndroidRuntimeException("Message must have a target.");  
  7.     }  
  8.     boolean needWake;  
  9.     synchronized (this) {  
  10.         if (mQuiting) {  
  11.             RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");  
  12.             Log.w("MessageQueue", e.getMessage(), e);  
  13.             return false;  
  14.         }  
  15.         msg.when = when;  
  16.         Message p = mMessages;  
  17.         //消息队列为空，将消息放在消息队列头上，并且设置需要唤醒消息循环线程  
  18.         if (p == null || when == 0 || when < p.when) {  
  19.             // New head, wake up the event queue if blocked.  
  20.             msg.next = p;  
  21.             mMessages = msg;  
  22.             needWake = mBlocked;  
  23.         } else {  
  24.             //将消息按时间排序插入到消息队列中  
  25.             needWake = mBlocked && p.target == null && msg.isAsynchronous();  
  26.             Message prev;  
  27.             for (;;) {  
  28.                 prev = p;  
  29.                 p = p.next;  
  30.                 if (p == null || when < p.when) {  
  31.                     break;  
  32.                 }  
  33.                 if (needWake && p.isAsynchronous()) {  
  34.                     needWake = false;  
  35.                 }  
  36.             }  
  37.             msg.next = p; // invariant: p == prev.next  
  38.             prev.next = msg;  
  39.         }  
  40.     }  
  41.     //如果需要唤醒消息循环线程  
  42.     if (needWake) {  
  43.         nativeWake(mPtr);  
  44.     }  
  45.     return true;  
  46. }  
final boolean enqueueMessage(Message msg, long when) {
	if (msg.isInUse()) {
		throw new AndroidRuntimeException(msg + " This message is already in use.");
	}
	if (msg.target == null) {
		throw new AndroidRuntimeException("Message must have a target.");
	}
	boolean needWake;
	synchronized (this) {
		if (mQuiting) {
			RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
			Log.w("MessageQueue", e.getMessage(), e);
			return false;
		}
		msg.when = when;
		Message p = mMessages;
		//消息队列为空，将消息放在消息队列头上，并且设置需要唤醒消息循环线程
		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 {
			//将消息按时间排序插入到消息队列中
			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;
		}
	}
	//如果需要唤醒消息循环线程
	if (needWake) {
		nativeWake(mPtr);
	}
	return true;
}


当前消息队列为空时，这时候消息循环线程一般就是处于空闲等待状态，这时候就要唤醒它，当消息队列不为空时，这时候就不需要唤醒消息循环线程。通过JNI调用NativeMessageQueue对象的wake函数：

[cpp] view plain copy print ?
  1. static void android_os_MessageQueue_nativeWake(JNIEnv* env, jobject obj, jint ptr) {  
  2.     NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);  
  3.     return nativeMessageQueue->wake();  
  4. }  
  5.   
  6. void NativeMessageQueue::wake() {  
  7.     mLooper->wake();  
  8. }  
static void android_os_MessageQueue_nativeWake(JNIEnv* env, jobject obj, jint ptr) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    return nativeMessageQueue->wake();
}

void NativeMessageQueue::wake() {
    mLooper->wake();
}

最后通过调用C++的Looper对象的wake函数来唤醒正在睡眠的消息循环线程

[cpp] view plain copy print ?
  1. void Looper::wake() {  
  2.     ssize_t nWrite;  
  3.     do {  
  4.         nWrite = write(mWakeWritePipeFd, "W", 1);  
  5.     } while (nWrite == -1 && errno == EINTR);  
  6.   
  7.     if (nWrite != 1) {  
  8.         if (errno != EAGAIN) {  
  9.             ALOGW("Could not write wake signal, errno=%d", errno);  
  10.         }  
  11.     }  
  12. }  
void Looper::wake() {
    ssize_t nWrite;
    do {
        nWrite = write(mWakeWritePipeFd, "W", 1);
    } while (nWrite == -1 && errno == EINTR);

    if (nWrite != 1) {
        if (errno != EAGAIN) {
            ALOGW("Could not write wake signal, errno=%d", errno);
        }
    }
}
函数只是通过打开文件描述符mWakeWritePipeFd往管道的写入一个"W"字符串。往管道写入内容的目的是为了唤醒消息循环线程。这里我们知道，对于Java层使用Handler对象发送的消息都是存储在MessageQueue对象中。

Runnable对象发送过程


Handler对象不仅可以往线程消息队列中发送一个消息，同时可以发送一个Runnable对象到消息队列中
[cpp] view plain copy print ?
  1. public final boolean post(Runnable r)  
  2. {  
  3.    return  sendMessageDelayed(getPostMessage(r), 0);  
  4. }  
public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}
该函数调用getPostMessage函数将Runnable对象封装为消息Message对象，然后按上述消息发送过程将该消息发送到消息队列中。
[cpp] view plain copy print ?
  1. private static Message getPostMessage(Runnable r) {  
  2.     Message m = Message.obtain();  
  3.     m.callback = r;  
  4.     return m;  
  5. }  
private static Message getPostMessage(Runnable r) {
	Message m = Message.obtain();
	m.callback = r;
	return m;
}
将post的Runnable封装为一个消息来处理。

消息循环过程

[cpp] view plain copy print ?
  1. public static void loop() {  
  2.     final Looper me = myLooper();  
  3.     if (me == null) {  
  4.         throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
  5.     }  
  6.     final MessageQueue queue = me.mQueue;  
  7.     Binder.clearCallingIdentity();  
  8.     final long ident = Binder.clearCallingIdentity();  
  9.     for (;;) {  
  10.         //不断地从消息队列queue中获取下一个要处理的消息msg  
  11.         Message msg = queue.next(); // might block  
  12.         if (msg == null) {  
  13.             //退出消息循环  
  14.             return;  
  15.         }  
  16.         Printer logging = me.mLogging;  
  17.         if (logging != null) {  
  18.             logging.println(">>>>> Dispatching to " + msg.target + " " +  
  19.                     msg.callback + ": " + msg.what);  
  20.         }  
  21.         //调用消息对应目标Handler来分发该消息  
  22.         msg.target.dispatchMessage(msg);  
  23.         if (logging != null) {  
  24.             logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
  25.         }  
  26.         final long newIdent = Binder.clearCallingIdentity();  
  27.         if (ident != newIdent) {  
  28.             Log.wtf(TAG, "Thread identity changed from 0x"  
  29.                     + Long.toHexString(ident) + " to 0x"  
  30.                     + Long.toHexString(newIdent) + " while dispatching to "  
  31.                     + msg.target.getClass().getName() + " "  
  32.                     + msg.callback + " what=" + msg.what);  
  33.         }  
  34.         msg.recycle();  
  35.     }  
  36. }  
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;
	Binder.clearCallingIdentity();
	final long ident = Binder.clearCallingIdentity();
	for (;;) {
		//不断地从消息队列queue中获取下一个要处理的消息msg
		Message msg = queue.next(); // might block
		if (msg == null) {
			//退出消息循环
			return;
		}
		Printer logging = me.mLogging;
		if (logging != null) {
			logging.println(">>>>> Dispatching to " + msg.target + " " +
					msg.callback + ": " + msg.what);
		}
		//调用消息对应目标Handler来分发该消息
		msg.target.dispatchMessage(msg);
		if (logging != null) {
			logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
		}
		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.recycle();
	}
}
函数首先不断地从消息队列mQueue中去获取下一个要处理的消息msg，如果取得的消息为null，就表示要退出消息循环，否则就要调用这个消息的目标Handler对象的dispatchMessage成员函数来处理这个消息。
[cpp] view plain copy print ?
  1. final Message next() {  
  2.     int pendingIdleHandlerCount = -1; // -1 only during first iteration  
  3.     int nextPollTimeoutMillis = 0;  
  4.     for (;;) {  
  5.         if (nextPollTimeoutMillis != 0) {  
  6.             Binder.flushPendingCommands();  
  7.         }  
  8.         //检查有没有消息请求，及被监控的IO接口上没有有事件发生，如果没有，则当前消息循环线程进入睡眠等待状态  
  9.         nativePollOnce(mPtr, nextPollTimeoutMillis);  
  10.         //如果mQuiting为false，表示退出消息循环，返回null，从而可以退出loop函数的for循环  
  11.         synchronized (this) {  
  12.             if (mQuiting) {  
  13.                 return null;  
  14.             }  
  15.             // Try to retrieve the next message.  Return if found.  
  16.             final long now = SystemClock.uptimeMillis();  
  17.             Message prevMsg = null;  
  18.             Message msg = mMessages;  
  19.             if (msg != null && msg.target == null) {  
  20.                 //从消息队列中查找异步消息对象  
  21.                 do {  
  22.                     prevMsg = msg;  
  23.                     msg = msg.next;  
  24.                 } while (msg != null && !msg.isAsynchronous());  
  25.             }  
  26.             //如果消息队列中有消息  
  27.             if (msg != null) {  
  28.                 //当前时间小于消息执行时间  
  29.                 if (now < msg.when) {  
  30.                     //计算下一次轮询等待时间  
  31.                     nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);  
  32.                 } else {//当前时间大于或等于消息执行时间  
  33.                     mBlocked = false;  
  34.                     if (prevMsg != null) {  
  35.                         prevMsg.next = msg.next;  
  36.                     } else {  
  37.                         mMessages = msg.next;  
  38.                     }  
  39.                     msg.next = null;  
  40.                     if (false) Log.v("MessageQueue", "Returning message: " + msg);  
  41.                     msg.markInUse();  
  42.                     return msg;  
  43.                 }  
  44.             } else {  
  45.                 // -1表示下次调用nativePollOnce时，如果消息队列中没有消息，就进入无限等待状态。  
  46.                 nextPollTimeoutMillis = -1;  
  47.             }  
  48.             //如果应用程序注册了IdleHandler接口来处理一些事情，那么在进入空闲等待状态前，会先执行这里IdleHandler  
  49.             if (pendingIdleHandlerCount < 0 && (mMessages == null || now < mMessages.when)) {  
  50.                 pendingIdleHandlerCount = mIdleHandlers.size();  
  51.             }  
  52.             //如果没有IdleHandler需要执行，则进入下一次循环  
  53.             if (pendingIdleHandlerCount <= 0) {  
  54.                 // No idle handlers to run.  Loop and wait some more.  
  55.                 mBlocked = true;  
  56.                 continue;  
  57.             }  
  58.             if (mPendingIdleHandlers == null) {  
  59.                 mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];  
  60.             }  
  61.             mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);  
  62.         }  
  63.         //处理所有注册的IdleHandler  
  64.         for (int i = 0; i < pendingIdleHandlerCount; i++) {  
  65.             final IdleHandler idler = mPendingIdleHandlers[i];  
  66.             mPendingIdleHandlers[i] = null; // release the reference to the handler  
  67.             boolean keep = false;  
  68.             try {  
  69.                 keep = idler.queueIdle();  
  70.             } catch (Throwable t) {  
  71.                 Log.wtf("MessageQueue", "IdleHandler threw exception", t);  
  72.             }  
  73.             //如果返回值为false，那么就会从应用程序中移除这个IdleHandler，否则继续维护着这个IdleHandler  
  74.             if (!keep) {  
  75.                 synchronized (this) {  
  76.                     mIdleHandlers.remove(idler);  
  77.                 }  
  78.             }  
  79.         }  
  80.         pendingIdleHandlerCount = 0;  
  81.         //While calling an idle handler, a new message could have been delivered  
  82.         //so go back and look again for a pending message without waiting.  
  83.         nextPollTimeoutMillis = 0;  
  84.     }  
  85. }  
final Message next() {
	int pendingIdleHandlerCount = -1; // -1 only during first iteration
	int nextPollTimeoutMillis = 0;
	for (;;) {
		if (nextPollTimeoutMillis != 0) {
			Binder.flushPendingCommands();
		}
		//检查有没有消息请求，及被监控的IO接口上没有有事件发生，如果没有，则当前消息循环线程进入睡眠等待状态
		nativePollOnce(mPtr, nextPollTimeoutMillis);
		//如果mQuiting为false，表示退出消息循环，返回null，从而可以退出loop函数的for循环
		synchronized (this) {
			if (mQuiting) {
				return null;
			}
			// Try to retrieve the next message.  Return if found.
			final long now = SystemClock.uptimeMillis();
			Message prevMsg = null;
			Message msg = mMessages;
			if (msg != null && msg.target == null) {
				//从消息队列中查找异步消息对象
				do {
					prevMsg = msg;
					msg = msg.next;
				} while (msg != null && !msg.isAsynchronous());
			}
			//如果消息队列中有消息
			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;
					if (false) Log.v("MessageQueue", "Returning message: " + msg);
					msg.markInUse();
					return msg;
				}
			} else {
				// -1表示下次调用nativePollOnce时，如果消息队列中没有消息，就进入无限等待状态。
				nextPollTimeoutMillis = -1;
			}
			//如果应用程序注册了IdleHandler接口来处理一些事情，那么在进入空闲等待状态前，会先执行这里IdleHandler
			if (pendingIdleHandlerCount < 0 && (mMessages == null || now < mMessages.when)) {
				pendingIdleHandlerCount = mIdleHandlers.size();
			}
			//如果没有IdleHandler需要执行，则进入下一次循环
			if (pendingIdleHandlerCount <= 0) {
				// No idle handlers to run.  Loop and wait some more.
				mBlocked = true;
				continue;
			}
			if (mPendingIdleHandlers == null) {
				mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
			}
			mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
		}
		//处理所有注册的IdleHandler
		for (int i = 0; i < pendingIdleHandlerCount; i++) {
			final IdleHandler idler = mPendingIdleHandlers[i];
			mPendingIdleHandlers[i] = null; // release the reference to the handler
			boolean keep = false;
			try {
				keep = idler.queueIdle();
			} catch (Throwable t) {
				Log.wtf("MessageQueue", "IdleHandler threw exception", t);
			}
			//如果返回值为false，那么就会从应用程序中移除这个IdleHandler，否则继续维护着这个IdleHandler
			if (!keep) {
				synchronized (this) {
					mIdleHandlers.remove(idler);
				}
			}
		}
		pendingIdleHandlerCount = 0;
		//While calling an idle handler, a new message could have been delivered
		//so go back and look again for a pending message without waiting.
		nextPollTimeoutMillis = 0;
	}
}
函数首先进入JNI层的nativePollOnce函数检查消息队列中是否有消息，或者被监控的IO接口上是否有事件发送，如果有，则处理相应的消息或事件，否则当前消息循环线程就睡眠等待。
[cpp] view plain copy print ?
  1. static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,  
  2.         jint ptr, jint timeoutMillis) {  
  3.     //通过参数ptr取回在JNI层创建的NatvieMessageQueue对象  
  4.     NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);  
  5.     nativeMessageQueue->pollOnce(env, timeoutMillis);  
  6. }  
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jint ptr, jint timeoutMillis) {
	//通过参数ptr取回在JNI层创建的NatvieMessageQueue对象
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(env, timeoutMillis);
}
继续调用NatvieMessageQueue对象的pollOnce函数
[cpp] view plain copy print ?
  1. void NativeMessageQueue::pollOnce(JNIEnv* env, int timeoutMillis) {  
  2.     mInCallback = true;  
  3.     mLooper->pollOnce(timeoutMillis);  
  4.     mInCallback = false;  
  5.     if (mExceptionObj) {  
  6.         env->Throw(mExceptionObj);  
  7.         env->DeleteLocalRef(mExceptionObj);  
  8.         mExceptionObj = NULL;  
  9.     }  
  10. }  
void NativeMessageQueue::pollOnce(JNIEnv* env, int timeoutMillis) {
    mInCallback = true;
    mLooper->pollOnce(timeoutMillis);
    mInCallback = false;
    if (mExceptionObj) {
        env->Throw(mExceptionObj);
        env->DeleteLocalRef(mExceptionObj);
        mExceptionObj = NULL;
    }
}
参数timeoutMillis是指超时时间，如果在指定的超时时间内没有消息或者没有事件发送，函数则返回到Java层
[cpp] view plain copy print ?
  1. inline int pollOnce(int timeoutMillis) {  
  2.     return pollOnce(timeoutMillis, NULL, NULL, NULL);  
  3. }  
inline int pollOnce(int timeoutMillis) {
	return pollOnce(timeoutMillis, NULL, NULL, NULL);
}
[cpp] view plain copy print ?
  1. int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {  
  2.     int result = 0;  
  3.     for (;;) {  
  4.         //遍历已发生的事件请求，并返回该event及该事件的句柄  
  5.         while (mResponseIndex < mResponses.size()) {  
  6.             const Response& response = mResponses.itemAt(mResponseIndex++);  
  7.             int ident = response.request.ident;  
  8.             if (ident >= 0) {  
  9.                 int fd = response.request.fd;  
  10.                 int events = response.events;  
  11.                 void* data = response.request.data;  
  12.                 if (outFd != NULL) *outFd = fd;  
  13.                 if (outEvents != NULL) *outEvents = events;  
  14.                 if (outData != NULL) *outData = data;  
  15.                 return ident;  
  16.             }  
  17.         }  
  18.         if (result != 0) {  
  19.             if (outFd != NULL) *outFd = 0;  
  20.             if (outEvents != NULL) *outEvents = 0;  
  21.             if (outData != NULL) *outData = NULL;  
  22.             return result;  
  23.         }  
  24.         result = pollInner(timeoutMillis);  
  25.     }  
  26. }  
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) {
		//遍历已发生的事件请求，并返回该event及该事件的句柄
        while (mResponseIndex < mResponses.size()) {
            const Response& response = mResponses.itemAt(mResponseIndex++);
            int ident = response.request.ident;
            if (ident >= 0) {
                int fd = response.request.fd;
                int events = response.events;
                void* data = response.request.data;
                if (outFd != NULL) *outFd = fd;
                if (outEvents != NULL) *outEvents = events;
                if (outData != NULL) *outData = data;
                return ident;
            }
        }
        if (result != 0) {
            if (outFd != NULL) *outFd = 0;
            if (outEvents != NULL) *outEvents = 0;
            if (outData != NULL) *outData = NULL;
            return result;
        }
        result = pollInner(timeoutMillis);
    }
}
调用pollInner函数来进一步操作，如果pollInner返回值不等于0，这个函数就可以返回了。
[cpp] view plain copy print ?
  1. int Looper::pollInner(int timeoutMillis) {  
  2.     // Adjust the timeout based on when the next message is due.  
  3.     if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {  
  4.         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  5.         int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);  
  6.         if (messageTimeoutMillis >= 0 && (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {  
  7.             timeoutMillis = messageTimeoutMillis;  
  8.         }  
  9.     }  
  10.     // Poll.  
  11.     int result = ALOOPER_POLL_WAKE;  
  12.     mResponses.clear();  
  13.     mResponseIndex = 0;  
  14.     struct epoll_event eventItems[EPOLL_MAX_EVENTS];  
  15.     //调用epoll_wait检查epoll专用文件描述符mEpollFd所监控的文件描述符是否有IO事件发生，设置的超时时间为timeoutMillis  
  16.     int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);  
  17.     //如果监控的句柄上有事件产生或者超时时间到时，epoll_wait函数将返回，否则epoll_wait睡眠等待事件发生  
  18.     mLock.lock();  
  19.     //如果eventCount小于0，说明监控出错  
  20.     if (eventCount < 0) {  
  21.         if (errno == EINTR) {  
  22.             goto Done;  
  23.         }  
  24.         ALOGW("Poll failed with an unexpected error, errno=%d", errno);  
  25.         result = ALOOPER_POLL_ERROR;  
  26.         goto Done;  
  27.     }  
  28.     // 如果eventCount等于0，就说明是超时了  
  29.     if (eventCount == 0) {  
  30.         result = ALOOPER_POLL_TIMEOUT;  
  31.         goto Done;  
  32.     }  
  33.     //如果eventCount大于0，表示有事件发送  
  34.     for (int i = 0; i < eventCount; i++) {  
  35.         int fd = eventItems[i].data.fd;  
  36.         uint32_t epollEvents = eventItems[i].events;  
  37.         //如果在mWakeReadPipeFd文件描述符上发生了EPOLLIN事件，就说明消息队列里面有新的消息需要处理。因为当其它的线程向消息队列加入新的消息时，会调用Looper类的wake函数向这个管道写入新的内容来通知消息循环线程有新的消息需要处理  
  38.         if (fd == mWakeReadPipeFd) {  
  39.             if (epollEvents & EPOLLIN) {  
  40.                 //读取管道中的内容  
  41.                 awoken();  
  42.             } else {  
  43.                 ALOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);  
  44.             }  
  45.         //如果是其他被监控的句柄产生了某些事件  
  46.         } else {  
  47.             //得到该事件句柄在mRequests向量中的索引位置，变量mRequests以键值对的形式保存了所有添加的监控句柄  
  48.             ssize_t requestIndex = mRequests.indexOfKey(fd);  
  49.             if (requestIndex >= 0) {  
  50.                 //检查事件类型  
  51.                 int events = 0;  
  52.                 if (epollEvents & EPOLLIN) events |= ALOOPER_EVENT_INPUT;  
  53.                 if (epollEvents & EPOLLOUT) events |= ALOOPER_EVENT_OUTPUT;  
  54.                 if (epollEvents & EPOLLERR) events |= ALOOPER_EVENT_ERROR;  
  55.                 if (epollEvents & EPOLLHUP) events |= ALOOPER_EVENT_HANGUP;  
  56.                 //通过fd从mRequests向量中查找到对应的Request描述符，然后将该描述符与发送的事件封装为Response数据结构，并保存到向量mResponses中  
  57.                 pushResponse(events, mRequests.valueAt(requestIndex));  
  58.             } else {  
  59.                 ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "  
  60.                         "no longer registered.", epollEvents, fd);  
  61.             }  
  62.         }  
  63.     }  
  64. Done: ;  
  65.     //处理C++层的消息  
  66.     mNextMessageUptime = LLONG_MAX;  
  67.     //所有C++层的消息都封装为MessageEnvelope类型的变量并保存到mMessageEnvelopes链表中  
  68.     while (mMessageEnvelopes.size() != 0) {  
  69.         nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  70.         const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);  
  71.         //处理当前时刻之前的所有消息  
  72.         if (messageEnvelope.uptime <= now) {  
  73.             {   
  74.                 //取出处理该消息的Hanlder  
  75.                 sp<MessageHandler> handler = messageEnvelope.handler;  
  76.                 //取出该消息描述符  
  77.                 Message message = messageEnvelope.message;  
  78.                 //从mMessageEnvelopes链表中移除该消息  
  79.                 mMessageEnvelopes.removeAt(0);  
  80.                 //表示当前消息循环线程正在处理消息，处于唤醒状态，因此消息发送线程无需唤醒消息循环线程  
  81.                 mSendingMessage = true;  
  82.                 mLock.unlock();  
  83.                 //调用该消息Handler对象的handleMessage函数来处理该消息  
  84.                 handler->handleMessage(message);  
  85.             } // release handler  
  86.             mLock.lock();  
  87.             mSendingMessage = false;  
  88.             result = ALOOPER_POLL_CALLBACK;  
  89.         } else {  
  90.             // The last message left at the head of the queue determines the next wakeup time.  
  91.             mNextMessageUptime = messageEnvelope.uptime;  
  92.             break;  
  93.         }  
  94.     }  
  95.     // Release lock.  
  96.     mLock.unlock();  
  97.     //前面将监控句柄上发送的事件封装为Response对象并保存在mResponses向量中，这里就开始处理这些事件  
  98.     for (size_t i = 0; i < mResponses.size(); i++) {  
  99.         Response& response = mResponses.editItemAt(i);  
  100.         if (response.request.ident == ALOOPER_POLL_CALLBACK) {  
  101.             int fd = response.request.fd;  
  102.             int events = response.events;  
  103.             void* data = response.request.data;  
  104.             //调用这些句柄的callback回调函数来处理发送的事件  
  105.             int callbackResult = response.request.callback->handleEvent(fd, events, data);  
  106.             if (callbackResult == 0) {  
  107.                 removeFd(fd);  
  108.             }  
  109.             // Clear the callback reference in the response structure promptly because we  
  110.             // will not clear the response vector itself until the next poll.  
  111.             response.request.callback.clear();  
  112.             result = ALOOPER_POLL_CALLBACK;  
  113.         }  
  114.     }  
  115.     return result;  
  116. }  
int Looper::pollInner(int timeoutMillis) {
    // Adjust the timeout based on when the next message is due.
    if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);
        if (messageTimeoutMillis >= 0 && (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {
            timeoutMillis = messageTimeoutMillis;
        }
    }
    // Poll.
    int result = ALOOPER_POLL_WAKE;
    mResponses.clear();
    mResponseIndex = 0;
    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
	//调用epoll_wait检查epoll专用文件描述符mEpollFd所监控的文件描述符是否有IO事件发生，设置的超时时间为timeoutMillis
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    //如果监控的句柄上有事件产生或者超时时间到时，epoll_wait函数将返回，否则epoll_wait睡眠等待事件发生
    mLock.lock();
    //如果eventCount小于0，说明监控出错
    if (eventCount < 0) {
        if (errno == EINTR) {
            goto Done;
        }
        ALOGW("Poll failed with an unexpected error, errno=%d", errno);
        result = ALOOPER_POLL_ERROR;
        goto Done;
    }
    // 如果eventCount等于0，就说明是超时了
    if (eventCount == 0) {
        result = ALOOPER_POLL_TIMEOUT;
        goto Done;
    }
    //如果eventCount大于0，表示有事件发送
    for (int i = 0; i < eventCount; i++) {
        int fd = eventItems[i].data.fd;
        uint32_t epollEvents = eventItems[i].events;
		//如果在mWakeReadPipeFd文件描述符上发生了EPOLLIN事件，就说明消息队列里面有新的消息需要处理。因为当其它的线程向消息队列加入新的消息时，会调用Looper类的wake函数向这个管道写入新的内容来通知消息循环线程有新的消息需要处理
        if (fd == mWakeReadPipeFd) {
            if (epollEvents & EPOLLIN) {
				//读取管道中的内容
                awoken();
            } else {
                ALOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);
            }
		//如果是其他被监控的句柄产生了某些事件
        } else {
			//得到该事件句柄在mRequests向量中的索引位置，变量mRequests以键值对的形式保存了所有添加的监控句柄
            ssize_t requestIndex = mRequests.indexOfKey(fd);
            if (requestIndex >= 0) {
				//检查事件类型
                int events = 0;
                if (epollEvents & EPOLLIN) events |= ALOOPER_EVENT_INPUT;
                if (epollEvents & EPOLLOUT) events |= ALOOPER_EVENT_OUTPUT;
                if (epollEvents & EPOLLERR) events |= ALOOPER_EVENT_ERROR;
                if (epollEvents & EPOLLHUP) events |= ALOOPER_EVENT_HANGUP;
				//通过fd从mRequests向量中查找到对应的Request描述符，然后将该描述符与发送的事件封装为Response数据结构，并保存到向量mResponses中
                pushResponse(events, mRequests.valueAt(requestIndex));
            } else {
                ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "
                        "no longer registered.", epollEvents, fd);
            }
        }
    }
Done: ;
    //处理C++层的消息
    mNextMessageUptime = LLONG_MAX;
	//所有C++层的消息都封装为MessageEnvelope类型的变量并保存到mMessageEnvelopes链表中
    while (mMessageEnvelopes.size() != 0) {
        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
		//处理当前时刻之前的所有消息
        if (messageEnvelope.uptime <= now) {
            { 
				//取出处理该消息的Hanlder
                sp<MessageHandler> handler = messageEnvelope.handler;
				//取出该消息描述符
                Message message = messageEnvelope.message;
				//从mMessageEnvelopes链表中移除该消息
                mMessageEnvelopes.removeAt(0);
				//表示当前消息循环线程正在处理消息，处于唤醒状态，因此消息发送线程无需唤醒消息循环线程
                mSendingMessage = true;
                mLock.unlock();
				//调用该消息Handler对象的handleMessage函数来处理该消息
                handler->handleMessage(message);
            } // release handler
            mLock.lock();
            mSendingMessage = false;
            result = ALOOPER_POLL_CALLBACK;
        } else {
            // The last message left at the head of the queue determines the next wakeup time.
            mNextMessageUptime = messageEnvelope.uptime;
            break;
        }
    }
    // Release lock.
    mLock.unlock();
	//前面将监控句柄上发送的事件封装为Response对象并保存在mResponses向量中，这里就开始处理这些事件
    for (size_t i = 0; i < mResponses.size(); i++) {
        Response& response = mResponses.editItemAt(i);
        if (response.request.ident == ALOOPER_POLL_CALLBACK) {
            int fd = response.request.fd;
            int events = response.events;
            void* data = response.request.data;
			//调用这些句柄的callback回调函数来处理发送的事件
            int callbackResult = response.request.callback->handleEvent(fd, events, data);
            if (callbackResult == 0) {
                removeFd(fd);
            }
            // Clear the callback reference in the response structure promptly because we
            // will not clear the response vector itself until the next poll.
            response.request.callback.clear();
            result = ALOOPER_POLL_CALLBACK;
        }
    }
    return result;
}
前面介绍到，对于Java层发送的消息，都保存在Java层的MessageQueue对象中，当应用程序向消息循环线程中发送一个Java消息后，通过管道方式通知正在睡眠等待的消息循环线程，消息循环线程接收到管道事件后，从C++层返回到Java层处理Java消息。Android的消息循环机制Looper不仅可以处理Java层消息，同时可以处理native层的消息，所有的native消息都被封装为MessageEnvelope对象，并保存在Looper的成员变量mMessageEnvelopes向量中。同时Looper对外提供了addFd接口函数，应用程序可以通过该接口向消息循环线程添加一个需要监控的文件句柄，并注册事件处理回调函数，从而可以在监听到该句柄上的事件时，回调事件处理函数来处理相应的事件。
当mEpollFd所监控的文件描述符发生了要监控的IO事件后或者监控时间超时后，消息循环线程就从epoll_wait返回了，否则消息循环线程就会在epoll_wait函数中进入睡眠状态了。如果在mWakeReadPipeFd文件描述符上发生了EPOLLIN就说明应用程序Java层的消息队列中有新的消息需要处理，接下来它就会先调用awoken函数读取管道中的内容。
[cpp] view plain copy print ?
  1. void Looper::awoken() {  
  2.     char buffer[16];  
  3.     ssize_t nRead;  
  4.     do {  
  5.         //读取管道内容  
  6.         nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));  
  7.     } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));  
  8. }  
void Looper::awoken() {
    char buffer[16];
    ssize_t nRead;
    do {
		//读取管道内容
        nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
    } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
}
当读取完管道内容后，应用程序就可以发送一个Java消息到消息队列中，并再次通过写管道方式来通知正在睡眠等待的消息循环线程返回到Java层去处理消息。

Java消息处理过程

当应用程序通过Handler对象往消息循环线程发送一个Java消息后，会调用nativeWake()函数唤醒正睡眠在Native层的消息循环线程，消息循环线程被唤醒后，返回到Java层的MessageQueue类的next()函数，该函数从消息队列MessageQueue中取出消息，然后返回到Looper类的loop()函数中处理该消息：
[cpp] view plain copy print ?
  1. msg.target.dispatchMessage(msg);  
msg.target.dispatchMessage(msg);
这里调用发送消息Handler类的dispatchMessage函数来分发该消息，在 前面介绍Hanlder发送消息时，被发送的消息msg的target被设置为发送该消息的Handler对象：
[cpp] view plain copy print ?
  1. public void dispatchMessage(Message msg) {  
  2.     //如果handler发送的是一个Runnable对象消息，  
  3.     if (msg.callback != null) {  
  4.         handleCallback(msg);  
  5.     } else {  
  6.         //如果在构造handler对象时指定了Callback对象，则调用该Callback对象的handleMessage函数来处理消息  
  7.         if (mCallback != null) {  
  8.             if (mCallback.handleMessage(msg)) {  
  9.                 return;  
  10.             }  
  11.         }  
  12.         //调用handler对象的handleMessage函数来处理消息  
  13.         handleMessage(msg);  
  14.     }  
  15. }  
public void dispatchMessage(Message msg) {
	//如果handler发送的是一个Runnable对象消息，
	if (msg.callback != null) {
		handleCallback(msg);
	} else {
		//如果在构造handler对象时指定了Callback对象，则调用该Callback对象的handleMessage函数来处理消息
		if (mCallback != null) {
			if (mCallback.handleMessage(msg)) {
				return;
			}
		}
		//调用handler对象的handleMessage函数来处理消息
		handleMessage(msg);
	}
}
当Hanlder对象发送的是一个Runnable对象时，发送过程中实际上是将其封装为一个消息对象来发送的，只是在处理该消息的时候自动调用Runnable接口所实现的方法：
[cpp] view plain copy print ?
  1. private static void handleCallback(Message message) {  
  2.     message.callback.run();  
  3. }  
private static void handleCallback(Message message) {
	message.callback.run();
}
从Java消息处理过程我们可以总结如下：
1. 使用Handler对象发送一个Runnable对象，实际也是发送一个消息到消息队列，只是对该消息的处理自动调用Runnable接口所实现的方法；
2. 如果在构造Handler对象时指定了Callback对象，则该Handler发送的消息由指定Callback对象的handleMessage函数来处理；
3. 如果在构造Handler对象时，未指定Callback对象，则该Handler发送的消息由当前Hanlder的handleMessage函数来处理；

监控文件描述符注册过程


消息循环Looper不仅可以监控管道读端，而且可以监控其他通过addFd接口添加进来的设备句柄，向消息循环Looper添加监控设备句柄过程如下：
[cpp] view plain copy print ?
  1. int Looper::addFd(int fd, int ident, int events, ALooper_callbackFunc callback, void* data) {  
  2.     return addFd(fd, ident, events, callback ? new SimpleLooperCallback(callback) : NULL, data);  
  3. }  
int Looper::addFd(int fd, int ident, int events, ALooper_callbackFunc callback, void* data) {
    return addFd(fd, ident, events, callback ? new SimpleLooperCallback(callback) : NULL, data);
}
该函数将事件处理回调函数封装为SimpleLooperCallback对象，并调用另一个addFd函数将Socket接收端描述符添加到消息循环中监听：
[cpp] view plain copy print ?
  1. int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data) {  
  2.     if (!callback.get()) {  
  3.         if (! mAllowNonCallbacks) {  
  4.             ALOGE("Invalid attempt to set NULL callback but not allowed for this looper.");  
  5.             return -1;  
  6.         }  
  7.         if (ident < 0) {  
  8.             ALOGE("Invalid attempt to set NULL callback with ident < 0.");  
  9.             return -1;  
  10.         }  
  11.     } else {  
  12.         ident = ALOOPER_POLL_CALLBACK;  
  13.     }  
  14.     //设置监听的事件类型  
  15.     int epollEvents = 0;  
  16.     if (events & ALOOPER_EVENT_INPUT) epollEvents |= EPOLLIN;  
  17.     if (events & ALOOPER_EVENT_OUTPUT) epollEvents |= EPOLLOUT;  
  18.     { // acquire lock  
  19.         AutoMutex _l(mLock);  
  20.         //将请求监听的文件描述符封装为Request对象  
  21.         Request request;  
  22.         request.fd = fd;  
  23.         request.ident = ident;  
  24.         //callback注册为SimpleLooperCallback对象  
  25.         request.callback = callback;  
  26.         request.data = data;  
  27.         //初始化一个事件描述符  
  28.         struct epoll_event eventItem;  
  29.         memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union  
  30.         eventItem.events = epollEvents;  
  31.         eventItem.data.fd = fd;  
  32.         //以文件描述符为键从mRequests中查找对应的Request对象  
  33.         ssize_t requestIndex = mRequests.indexOfKey(fd);  
  34.         //如果添加的Request不存在，则向mEpollFd添加一个事件项  
  35.         if (requestIndex < 0) {  
  36.             int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);  
  37.             if (epollResult < 0) {  
  38.                 ALOGE("Error adding epoll events for fd %d, errno=%d", fd, errno);  
  39.                 return -1;  
  40.             }  
  41.             //将创建的Request对象以键值对的形式保存到Looper的成员变量mRequests中  
  42.             mRequests.add(fd, request);  
  43.         } else {  
  44.             //如果添加的Request已经存在，则修改该事件项  
  45.             int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, & eventItem);  
  46.             if (epollResult < 0) {  
  47.                 ALOGE("Error modifying epoll events for fd %d, errno=%d", fd, errno);  
  48.                 return -1;  
  49.             }  
  50.             //使用当前的request替换原有的request对象  
  51.             mRequests.replaceValueAt(requestIndex, request);  
  52.         }  
  53.     } // release lock  
  54.     return 1;  
  55. }  
int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data) {
    if (!callback.get()) {
        if (! mAllowNonCallbacks) {
            ALOGE("Invalid attempt to set NULL callback but not allowed for this looper.");
            return -1;
        }
        if (ident < 0) {
            ALOGE("Invalid attempt to set NULL callback with ident < 0.");
            return -1;
        }
    } else {
        ident = ALOOPER_POLL_CALLBACK;
    }
	//设置监听的事件类型
    int epollEvents = 0;
    if (events & ALOOPER_EVENT_INPUT) epollEvents |= EPOLLIN;
    if (events & ALOOPER_EVENT_OUTPUT) epollEvents |= EPOLLOUT;
    { // acquire lock
        AutoMutex _l(mLock);
		//将请求监听的文件描述符封装为Request对象
        Request request;
        request.fd = fd;
        request.ident = ident;
		//callback注册为SimpleLooperCallback对象
        request.callback = callback;
        request.data = data;
		//初始化一个事件描述符
        struct epoll_event eventItem;
        memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
        eventItem.events = epollEvents;
        eventItem.data.fd = fd;
		//以文件描述符为键从mRequests中查找对应的Request对象
        ssize_t requestIndex = mRequests.indexOfKey(fd);
		//如果添加的Request不存在，则向mEpollFd添加一个事件项
        if (requestIndex < 0) {
            int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
            if (epollResult < 0) {
                ALOGE("Error adding epoll events for fd %d, errno=%d", fd, errno);
                return -1;
            }
			//将创建的Request对象以键值对的形式保存到Looper的成员变量mRequests中
            mRequests.add(fd, request);
        } else {
			//如果添加的Request已经存在，则修改该事件项
            int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, & eventItem);
            if (epollResult < 0) {
                ALOGE("Error modifying epoll events for fd %d, errno=%d", fd, errno);
                return -1;
            }
			//使用当前的request替换原有的request对象
            mRequests.replaceValueAt(requestIndex, request);
        }
    } // release lock
    return 1;
}
函数首先创建一个Request对象来描述注册的Socket接收端文件描述符及其对应的回调函数，然后将创建的Request对象添加到Looper的成员变量mRequests中，同时使用epoll_ctl系统调用将Socket接收端文件描述符添加到epoll监听中。Request数据结构定义如下：
[cpp] view plain copy print ?
  1. struct Request {  
  2.     int fd; //被监控的设备句柄  
  3.     int ident;  
  4.     sp<LooperCallback> callback; //该句柄下发生事件的回调函数  
  5.     void* data;  
  6. };  
struct Request {
	int fd; //被监控的设备句柄
	int ident;
	sp<LooperCallback> callback; //该句柄下发生事件的回调函数
	void* data;
};
当添加到消息循环Looper监控的文件句柄上有事件发生时，将发生的事件及对应的请求封装为Response对象，Response数据结构定义如下：
[cpp] view plain copy print ?
  1. struct Response {  
  2.     int events; //事件  
  3.     Request request;//监控请求对象  
  4. };  
struct Response {
	int events; //事件
	Request request;//监控请求对象
};
同时添加到Looper成员变量mResponses中等候处理：
[cpp] view plain copy print ?
  1. void Looper::pushResponse(int events, const Request& request) {  
  2.     Response response;  
  3.     response.events = events;  
  4.     response.request = request;  
  5.     mResponses.push(response);  
  6. }  
void Looper::pushResponse(int events, const Request& request) {
    Response response;
    response.events = events;
    response.request = request;
    mResponses.push(response);
}
事件处理最终由注册的回调函数来完成：
[cpp] view plain copy print ?
  1. int callbackResult = response.request.callback->handleEvent(fd, events, data);  
int callbackResult = response.request.callback->handleEvent(fd, events, data);

Native消息发送过程


前面介绍了Android的消息循环Looper不仅可以处理Java层的消息，还可以处理native层的消息，Looper对外提供了消息发送接口：
[cpp] view plain copy print ?
  1. void Looper::sendMessage(const sp<MessageHandler>& handler, const Message& message) {  
  2.     nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  3.     sendMessageAtTime(now, handler, message);  
  4. }  
void Looper::sendMessage(const sp<MessageHandler>& handler, const Message& message) {
    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
    sendMessageAtTime(now, handler, message);
}
调用sendMessageAtTime函数来指定消息的执行时间，这里将消息的执行时间设置为当前时间
[cpp] view plain copy print ?
  1. void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,  
  2.         const Message& message) {  
  3.     size_t i = 0;  
  4.     { // acquire lock  
  5.         AutoMutex _l(mLock);  
  6.         size_t messageCount = mMessageEnvelopes.size();  
  7.         //从消息队列中查找当前消息执行时间大于其他消息执行时间的位置，即按消息执行时间排序  
  8.         while (i < messageCount && uptime >= mMessageEnvelopes.itemAt(i).uptime) {  
  9.             i += 1;  
  10.         }  
  11.         //将消息，消息处理Handler等封装为MessageEnvelope对象  
  12.         MessageEnvelope messageEnvelope(uptime, handler, message);  
  13.         //将创建的MessageEnvelope对象插入到消息队列mMessageEnvelopes中  
  14.         mMessageEnvelopes.insertAt(messageEnvelope, i, 1);  
  15.         //如果当前消息循环线程正处于唤醒状态，则返回，否则唤醒消息循环线程  
  16.         if (mSendingMessage) {  
  17.             return;  
  18.         }  
  19.     } // release lock  
  20.     //如果消息循环线程正处于睡眠状态，则唤醒消息循环线程  
  21.     if (i == 0) {  
  22.         wake();  
  23.     }  
  24. }  
void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler,
        const Message& message) {
    size_t i = 0;
    { // acquire lock
        AutoMutex _l(mLock);
        size_t messageCount = mMessageEnvelopes.size();
		//从消息队列中查找当前消息执行时间大于其他消息执行时间的位置，即按消息执行时间排序
        while (i < messageCount && uptime >= mMessageEnvelopes.itemAt(i).uptime) {
            i += 1;
        }
		//将消息，消息处理Handler等封装为MessageEnvelope对象
        MessageEnvelope messageEnvelope(uptime, handler, message);
		//将创建的MessageEnvelope对象插入到消息队列mMessageEnvelopes中
        mMessageEnvelopes.insertAt(messageEnvelope, i, 1);
		//如果当前消息循环线程正处于唤醒状态，则返回，否则唤醒消息循环线程
        if (mSendingMessage) {
            return;
        }
    } // release lock
    //如果消息循环线程正处于睡眠状态，则唤醒消息循环线程
    if (i == 0) {
        wake();
    }
}
该函数将消息封装为MessageEnvelope对象，并按时间顺序插入到消息队列mMessageEnvelopes中，MessageEnvelope类型封装了消息及消息对应的处理Handler，其定义如下：
[cpp] view plain copy print ?
  1. struct MessageEnvelope {  
  2.     MessageEnvelope() : uptime(0) { }  
  3.   
  4.     MessageEnvelope(nsecs_t uptime, const sp<MessageHandler> handler,  
  5.             const Message& message) : uptime(uptime), handler(handler), message(message) {  
  6.     }  
  7.     //消息处理时间  
  8.     nsecs_t uptime;  
  9.     //消息处理Handler对象  
  10.     sp<MessageHandler> handler;  
  11.     //消息对象  
  12.     Message message;  
  13. };  
struct MessageEnvelope {
	MessageEnvelope() : uptime(0) { }

	MessageEnvelope(nsecs_t uptime, const sp<MessageHandler> handler,
			const Message& message) : uptime(uptime), handler(handler), message(message) {
	}
	//消息处理时间
	nsecs_t uptime;
	//消息处理Handler对象
	sp<MessageHandler> handler;
	//消息对象
	Message message;
};
native消息发送过程就是将消息封装为MessageEnvelope对象并插入到消息循环Looper的成员变量mMessageEnvelopes中，前面介绍的消息循环过程中，消息循环线程通过遍历消息队列mMessageEnvelopes来处理队列中的所有消息
[cpp] view plain copy print ?
  1. //所有C++层的消息都封装为MessageEnvelope类型的变量并保存到mMessageEnvelopes链表中  
  2. while (mMessageEnvelopes.size() != 0) {  
  3.     nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  4.     const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);  
  5.     //处理当前时刻之前的所有消息  
  6.     if (messageEnvelope.uptime <= now) {  
  7.         {   
  8.             //取出处理该消息的Hanlder  
  9.             sp<MessageHandler> handler = messageEnvelope.handler;  
  10.             //取出该消息描述符  
  11.             Message message = messageEnvelope.message;  
  12.             //从mMessageEnvelopes链表中移除该消息  
  13.             mMessageEnvelopes.removeAt(0);  
  14.             //表示当前消息循环线程正在处理消息，处于唤醒状态，因此消息发送线程无需唤醒消息循环线程  
  15.             mSendingMessage = true;  
  16.             mLock.unlock();  
  17.             //调用该消息Handler对象的handleMessage函数来处理该消息  
  18.             handler->handleMessage(message);  
  19.         } // release handler  
  20.         mLock.lock();  
  21.         mSendingMessage = false;  
  22.         result = ALOOPER_POLL_CALLBACK;  
  23.     } else {  
  24.         // The last message left at the head of the queue determines the next wakeup time.  
  25.         mNextMessageUptime = messageEnvelope.uptime;  
  26.         break;  
  27.     }  
  28. }  
//所有C++层的消息都封装为MessageEnvelope类型的变量并保存到mMessageEnvelopes链表中
while (mMessageEnvelopes.size() != 0) {
	nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
	const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
	//处理当前时刻之前的所有消息
	if (messageEnvelope.uptime <= now) {
		{ 
			//取出处理该消息的Hanlder
			sp<MessageHandler> handler = messageEnvelope.handler;
			//取出该消息描述符
			Message message = messageEnvelope.message;
			//从mMessageEnvelopes链表中移除该消息
			mMessageEnvelopes.removeAt(0);
			//表示当前消息循环线程正在处理消息，处于唤醒状态，因此消息发送线程无需唤醒消息循环线程
			mSendingMessage = true;
			mLock.unlock();
			//调用该消息Handler对象的handleMessage函数来处理该消息
			handler->handleMessage(message);
		} // release handler
		mLock.lock();
		mSendingMessage = false;
		result = ALOOPER_POLL_CALLBACK;
	} else {
		// The last message left at the head of the queue determines the next wakeup time.
		mNextMessageUptime = messageEnvelope.uptime;
		break;
	}
}
1.Android应用程序的消息处理机制由消息循环、消息发送和消息处理三个部分组成的。
2.消息循环线程通过Linux系统的Epoll机制中的epoll_wait函数失眠等待消息到来；
3.当应用程序向消息循环线程发送一个Java消息时，通过管道方式唤醒消息循环线程，并返回Java层处理消息；
4.当应用程序向消息循环线程发送一个Native消息时，仍然通过管道方式唤醒消息循环线程；
5.消息循环线程不仅可以处理消息，同时可以监控并处理指定设备句柄上发送的事件；
Fate_I_C
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android消息循环机制
crazy_jack
06-19 1万+
转载请注明出处：http://blog.csdn.net/crazy1235/article/details/50771703Android的消息循环机制主要先关的类有： Handler Looper Message MessageQueue ActivityThread 实际上应用程序启动的时候，会创建一个UI线程，然后该线程关联一个消息队列，相关操作封装一个个消息放入队列中，主线程会不断循环从队
Android开发之消息处理机制（二）——消息循环
wangxiaohigh
09-03 138
Android开发之消息处理机制（二）——消息循环 /* * Android开发之消息处理机制（二）——消息循环 * 北京Android俱乐部群：167839253 * Created on: 2011-9-1 * Author: blueeagle * Email: liujiaxiang@gmail.com */ 先介绍一下如何在Android应用程序中使用后台线程和U...
android消息循环
tiantangniaochao的博客
03-15 471
android消息循环的形象描述 android消息循环的本质以及原理(pipe) 例子巩固 推荐博文android消息循环的描述android系统有一个核心的特点，那就是android的每一个应用程序都有一个消息队列，每一个应用程序的主线程(ActivityThread)不断地从这个消息队列里面取出消息(looper消息循环)，然后由对应的回调函数处理(回调函数用Handler注册)。说白了
Android消息循环
zyfzhangyafei的专栏
03-17 555
为什么一个线程需要消息循环和消息处理： 如果这个线程需要处理的工作是不需要与其它线程交互的，简单的工作，那么你可以直接用thread，不需要引入消息循环与处理机制。 但是如果你的线程需要与其它的线程交互，特别是线程本身要处理的工作是分步的， 且各部分工作间是有一个相互状态依赖关系的时候，引入消息循环与处理机制就非常有必要。消息循环与处理机制的引入，让线程的控制和交互变得友好。构成消息机制的几个
Android 按键消息流程源码分析
最新发布
05-08
### Android按键消息流程源码分析 #### 一、概述 在Android系统中，键盘按键事件的管理和处理是一项关键任务。整个流程涉及多个层次，从硬件层的Linux内核驱动到应用层的应用程序，其间还包括了Android框架层。...
Android 系统启动流程源码分析
05-07
### Android系统启动流程源码分析 #### 一、Init 进程启动 **Init 进程**是一个由内核启动的用户级进程。当内核完成自身加载后，接下来的任务便是启动用户空间的第一个进程——`init`。此进程在Android系统中扮演...
Android应用源码安卓源码（172个合集）.zip
05-29
Android模仿乐淘的应用程序分析源码.zip Android游戏源码——忍者快跑.rar Android自动发送短信.rar Android自动开关机实现.rar Android视频采集+RTSP完整代码（可用） Android远程登录含有loading登录效.zip Angle ...
Android应用源码之安卓飞机游戏.zip
06-07
同时，源码分析有助于提升问题解决能力，因为你可以直接查看代码逻辑，找出潜在的bug或性能瓶颈。 在这款安卓飞机游戏中，我们可以学习到以下关键的Android开发技术： 1. **图形渲染**：游戏通常涉及到大量的图形...
Android Handler消息派发机制源码分析
09-02
本文将深入解析Android Handler的消息派发机制源码，帮助开发者理解其内部工作原理。 首先，我们从`sendMessage`方法开始。当我们调用`sendMessage(Message msg)`时，实际上它会通过`sendMessageDelayed(msg, 0)`...
Android之循环队列操作
02-02
队列特性：先进先出（FIFO)——先进队列的元素先出队列。下面以一个简单的例子实现循环队列的操作。博客地址：http://blog.csdn.net/bingdianlanxin，有问题欢迎留言。
Android 中的消息循环简介
永远即等待的专栏
06-19 3684
这里有三个很重要的概念： 1，Looper 默认的工作线程是没有与之关联的消息循环，可以通过Looper类来运行消息循环。进入消息循环后，该消息循环会一直处理消息，直接退出消息循环。 调用Looper.prepare()方法来创建消息循环，调用Looper.loop()方法来开始消息循环。 下面代码示例了如何实现一个带有消息循环的线程类，这个线程类关联了一个Handler。
Android 消息循环机制
u011279649的专栏
07-11 326
public final class ActivityThread { ...... public static final void main(String[] args) { ...... Looper.prepareMainLooper(); ...... ActivityThread thread = new ActivityThread(); thread.attach(fal...
Android消息循环原理
灵魂工程师
01-28 106
Android 消息循环知识
chuoyijie4596的博客
06-25 109
Android应用程序的主线程就是我们理解的界面线程，主要负责界面响应事件，所以需要避免其他不相干的事情在里面操作。如果主线程不能快速响应界面事件，将会得到一个很差的体验效果和ANR，那将是不能忍的一件事。如果有一个耗时操作或者其他和界面不相干的操作，建议是放在异步线程...
Android Q消息循环：休眠、唤醒的底层原理及native层源码分析
热门推荐
卜大爷的博客
05-20 2万+
本文将分析Handler消息机制的内核层实现，以及Handler机制native层源码分析。我们将讨论消息循环的休眠、唤醒的实现原理，以及它们依赖的epoll机制的使用介绍等内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值