Android UI 主线程，啥玩意？还有Handler+Looper+MessageQueue几个意思？

写在前面：以前有什么知识，都是写在云笔记里，因为有很多只是草稿，发出来怕误导别人。而且，要发出来就得严肃的写了，多麻烦。最近感觉人老了，有些事看开了，决定要分享，哪怕多花点时间，错就错，留着让别人指正呗。也许多年以后，我不做技术了，还能回忆回忆。好吧，let’s go…

以前写App，都是迅速百度一下，复制黏贴修改，就O了！但作为一个在IC公司的人，做framework的人，竟然没去了解一下framework，实属罪过！我印象中，最没认真去研究的，就是UI主线程了。

每个android教程，都说更新UI要在主线程，要这么做，只要一个Handler就O了。但很多人不知道真正原理是啥。下面贴个例子。

package com.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Message;
import android.util.Log;
import android.os.Handler;
import android.view.ImageView;

public class UIHandlerActivity extends Activity {
public static final String TAG = "UIHandlerActivity";
public static final int MSG_TEST = 1;
public static final Handler mHandler;
public ImageView mImageView;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mImageView.findViewById(R.id.image);
Log.d(TAG, "The main thread id = " + Thread.currentThread().getId() + "/n");
mHandler = new Handler(){
public void handleMessage (Message msg)
{
switch(msg.what)
{
case MSG_TEST:
Log.d(TAG, "The handler thread id = " + Thread.currentThread().getId());
mImageView.setImageDrawable(getContext().getDrawable(R.drawable.ic_play));
break;
}
}
};

new myThread().start();
}

class myThread extends Thread
{
public void run()
{
Message msg = new Message();
msg.what = MSG_TEST;
mHandler.sendMessage(msg);
//或者mHandler.obtainMessage(MSG_TEST).sendToTarget();
Log.d(TAG, "The worker thread id = " + Thread.currentThread().getId() + "/n");
}
}
}

为啥new 一个Handler，把画UI的事情放在handleMessage，就算在UI主线程干活了呢？其实这样从源头说起。

首先的首先，先给出个结论，就是Android app使用消息机制实现线程间的通信，线程通过Looper建立自己的消息循环，MessageQueue是FIFO的消息队列，Looper负责从MessageQueue中取出消息，并且分发到消息指定目标Handler对象。Handler对象绑定到线程的局部变量Looper，封装了发送消息和处理消息的接口。

（PS: 不要晕，看不懂就先跳过。。。^^）

写过代码的都知道，不管是C还是java，都有一个main函数作为主线程的入口。对android的一个应用程序来说，ActivityThread的main函数就是入口。只是android已经把这个main全部写好，不需要你写而已。

ActivityThread其实就是我们经常说的UI thread，也就是主线程。它的main函数恰恰创建了Looper+MessageQueue+Handler的一套东西。

ActivityThread

final ApplicationThread mAppThread = new ApplicationThread();
final Looper mLooper = Looper.myLooper();
final H mH = new H();
......
public static final void main(String[] args) {
SamplingProfilerIntegration.start();
……
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
……
Looper.loop();
……
}

来看一下这个main函数。

a) Looper.prepareMainLooper();

该函数创建了Looper。

b) sMainThreadHandler = thread.getHandler();

其实就指向了mH，mH就是Handler，它可以发送/处理各种高大上的消息。

private class H extends Handler {
public static final int LAUNCH_ACTIVITY         = 100;
public static final int PAUSE_ACTIVITY          = 101;
public static final int PAUSE_ACTIVITY_FINISHING= 102;
public static final int STOP_ACTIVITY_SHOW      = 103;
public static final int STOP_ACTIVITY_HIDE      = 104;

c) Looper.loop();

Loop开始转起来。loop()函数其实就是一个while循环。不断的从MessageQueue取出消息（queue.next()），然后转发消息（dispatchMessage）。

/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
msg.target.dispatchMessage(msg);
}

也就是说，一个android程序，首先从ActivityThread的main函数启动，创建了一个主线程。

ActivityManagerService通过binder，与ActivityThread取得联系，并调用相关API，启动某个activity。

ActivityThread内部，启动某个activity就用了looper+message+handle一套东西。

大致流程如下。

a) scheduleLaunchActivity

b) sendMessage(H.LAUNCH_ACTIVITY, r) 传说中的mH发送消息，looper会接收消息，按先进先出的原则存储/转发消息，转发其实就是转发到mH，于是回到mH的回调函数handleMessage。

c) mH处理消息，执行handleLaunchActivity

d) performLaunchActivity

e) mInstrumentation.callActivityOnCreate(activity, r.state);

于是乎，进入到了我们自己写的OnCreate函数了！！

接下来，说一下Handler+Looper+MessageQueue。

Handler+Looper+MessageQueue详解

通过上文，我们知道，一个application有一个UI主线程，对应一个Looper和MesageQueue，还有一个Handler。

为啥我们自己在某个Activity内部又写了一个Handler，也能自己转起来呢？简单的说，是因为一个Looper和MessageQueue可以指向多个Handler！而我们新建的Handler指向了ActivityThread已经创建好的Looper和MesageQueue。

要解释这个，有必要看一下Handler的代码。

/**
* Default constructor associates this handler with the {@link Looper} for the
* current thread.
*
* If this thread does not have a looper, this handler won't be able to receive messages
* so an exception is thrown.
*/
public Handler() {
this(null, false);
}

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;
mCallback = callback;
mAsynchronous = async;
}

假设我们new了3个Handler，这3个Handler对象，都会执行Looper的静态函数myLooper()。来看一下这个函数。

final MessageQueue mQueue;
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static Looper myLooper() {
return sThreadLocal.get();
}
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));
}

/**
* Initialize the current thread as a looper, marking it as an
* application's main looper. The main looper for your application
* is created by the Android environment, so you should never need
* to call this function yourself.  See also: {@link #prepare()}
*/
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 MessageQueue myQueue() {
return myLooper().mQueue;
}

private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

由于在ActivityThread已经执行过prepareMainLooper，因此sThreadLocal存了一个Looper对象。

当别人调用myLooper（）时，sThreadLocal.get()获得的值，仍是同一个Looper对象。

也就是说，在当前的application，不管new几个Handler，Handler内部的mLooper变量都指向了主线程的Looper，内部的mQueue指向了主线程的mQueue（因为new一个Looper的时候，同时也new一个MessageQueue，因此也意味着指向同一个MessageQueue）。

有了上面的结论，我们就明白了，为啥写一个Activity，只需要简单的写一个Handler，实现handleMessage就可以实现异步通信了。

好了，接下来看看我们用Handler发消息，处理消息的过程。

我们经常看到，发消息简单的一句话就行。

mHandler.obtainMessage(MSG_SUCCESS).sendToTarget();

几个意思呢？

首先，mHandler.obtainMessage(MSG_SUCCESS)，相当于new了一个Message。并且该Message会绑定到当前的Handler(其实就是他的内部变量target等于当前的mHandler)。且看其定义就明白。

/**
* Same as {@link #obtainMessage()}, except that it also sets the what member of the returned Message.
*
* @param what Value to assign to the returned Message.what field.
* @return A Message from the global message pool.
*/
public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}

看一下Message如何实现。

public static Message obtain() {
......
return new Message();
}

public static Message obtain(Handler h, int what) {
Message m = obtain();
m.target = h;
m.what = what;

return m;
}

好了，那Message的一个对象，sendToTarget又会发生什么呢？

看一下Message的sendToTarget。

/**
* Sends this Message to the Handler specified by {@link #getTarget}.
* Throws a null pointer exception if this field has not been set.
*/
public void sendToTarget() {
target.sendMessage(this);
}

也就是，相当于执行。

mHandler.sendMessage(本消息);

好吧，又回到了Handler的sendMessage函数。来看一下。

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);
}

最终调用到sendMessageAtTime，当看到

MessageQueue queue = mQueue;

我们就知道，把消息给queue到主线程的MessageQueue了！！！！

由上文已经知道，主线程的Looper会不断的从MessageQueue里拿出消息，然后分发（其实就是Looper的loop()函数干了这个事）。

也就是说，主线程的Looper，其loop()函数一个个拿出消息，上文贴出的loop()函数可以看到，拿出一个msssage执行了

msg.target.dispatchMessage(msg);

也就是说，指向了message对应的Handler的dispatchMessage函数。

现在，又回到了Handler了，且看他的dispatchMessage

/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}

/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}

也就是说，调用了dispatchMessage，最终就会调用handleMessage，而这个handleMessage是我们new一个Handler必须实现的回调函数，来处理自己想要关心的消息！

好了，现在整条路都理清楚了，是不是发现没辣么复杂？~~^^~~

总结一下。

一个android application，会有一个UI主线程。（不是Activity喔）。

UI主线程由android系统帮我们启动，不需要操心。

启动后，会实例化一个Looper和MessageQueue，甚至还有一个Handler。

这3个默认的东西，分别是如下作用。

Looper，消息泵，不断的从MessageQueue拿出消息，然后分发。

MessageQueue存储各种Message。

Handler，处理消息。默认的那个Handler（即ActivityThread创建的Handler），做的是很高大上的工作，比如，帮我们启动想要的activity，横竖屏切换，接收消息等，但我们看不见也不需要关心。

这些事做完后，会调用到Activity的oncreate函数，开始执行我们自己想要做的事情。

一个Looper对应一个MessageQueue，但可以对应多个Handler。

在某个Activity实例化一个Handler都会使用android背后默默创建的Looper和Message。对写app的人来说，都不需要关心消息怎么转，只需要负责发消息，收消息就行了！

Handler的用途

如前文所说，我们new一个Handler，是运行在UI主线程中的，Handler通过handleMessage，来更新我们想要的UI动作，比如画个图呀，动态更新文字呀啥的。总之，所有和UI更新有关的，都放到Handler中。

但是，和UI无关的事情，又特别耗时间的，那就别麻烦Handler了，他管理UI已经很辛苦了，而且如果你做事情耗时，Handler光把时间花在这些上了，没空去更新UI，会造成UI很卡，所以这些事应该起一个子线程来搞了。

一般子线程与UI主线程的合作关系是：

子线程去做各种耗时的事情，忙完了，就发一个消息，消息体放着好不容易耗时做完的结果，消息放到MessageQuue，然后经过Loop一转，分发到Handler对象，处理这个结果。

下面就给出个经典的例子。

public class MyHandlerActivity extends Activity {
Button button;
MyHandler myHandler;

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.handlertest);

button = (Button) findViewById(R.id.button);
myHandler = new MyHandler();
// 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据.我们在onCreate new，所以就绑定到UI主线程。

MyThread m = new MyThread();
new Thread(m).start();
}

/**
* 接受消息,处理消息 ,此Handler会与当前主线程一块运行
* */

class MyHandler extends Handler {
public MyHandler() {
}

public MyHandler(Looper L) {
super(L);
}

// 子类必须重写此方法,接受数据
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
Log.d("MyHandler", "handleMessage......");
super.handleMessage(msg);
// 此处可以更新UI
Bundle b = msg.getData();
String txt = "" + b.getInt("txt");
MyHandlerActivity.this.button.setText(txt);

}
}

class MyThread implements Runnable {
int demo_txt = 1;
public void run() {
while(1) {
//做各种耗时的累活，咱这里装睡。很多usecase是去网络上download数据。
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

Log.d("thread.......", "mThread........");
Message msg = new Message();
Bundle b = new Bundle();// 存放数据
b.putInt("txt", demo_txt++);
msg.setData(b);

MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI
}
}
}
}

.

结束

所以啦，android系统确实有人家的好，让写app的人只需要做很少的工作，就可以写一个app，入门很快。

不扯了，吃饭去了！^^