转 Android的消息处理机制

浏览数：29 / 时间：2015年06月11日

来自：http://blog.csdn.net/andyhuabing/article/details/7368217

Windows编程的朋友可能知道Windows程序是消息驱动的，并且有全局的消息循环系统。而Android应用程序也是消息驱动的，按道理来说也应该提供消息循环机制。Android通过Looper、Handler来实现消息循环机制，Android消息循环是针对线程的（每个线程都可以有自己的消息队列和消息循环）。

在 Android 系统，这些工作由由由Looper 及 Handler　来完成。

先分析Looper类：
主要提供负责线程的消息循环和消息队列

class LooperThread extends Thread {
public Handler mHandler;

public void run() {
Looper.prepare(); // 准备。。。

mHandler = new Handler() {
public void handleMessage(Message msg) { // 消息处理
// process incoming messages here
}
};

Looper.loop(); // 进入消息循环
}
}

下面Looper类的准备函数：
private static final ThreadLocal sThreadLocal = new ThreadLocal();

public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}

这里利用 ThreadLocal 线程局部存储变量将将Looper与调用线程关联起来。
而消息处理流程如何呢？
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static final void loop() {
Looper me = myLooper(); // 线程中存储的Looper对象
MessageQueue queue = me.mQueue; // Looper类中的消息队列
while (true) {
Message msg = queue.next(); // might block 获取消息
//if (!me.mRun) {
// break;
//}
if (msg != null) {
if (msg.target == null) {
// No target is a magic identifier for the quit message.
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg); // 利用 Target 注册的方法处理消息
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
msg.recycle();
}
}
}

可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。

在android系统，UI线程就是消息的主线程，在 ActivityThread.java 中创建：
public static final void main(String[] args) {
Looper.prepareMainLooper();

Looper.loop(); //消息循环处理
}

-->
public static final void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
if (Process.supportsProcesses()) {
myLooper().mQueue.mQuitAllowed = false;
}
}

private synchronized static void setMainLooper(Looper looper) {
mMainLooper = looper;
}

再来分析 Handler 类：
主要提供负责将消息加入到特定的Looper消息队列中，并分发和处理访消息队列中的消息，构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper创建。

请看如下代码即可明白：
public Handler(Looper looper, Callback callback) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
}

这里也同时告诉我们将消息放入到主线程的消息队列中，只需要创建Hanlde对象时以主线程的Looper创建即可。则sendMessage及handleMessage都会在主线程中进行处理。

再看如下变量：
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;

这里也有队列，Looper对象及回调函数类，通过 Handler 不同构造函数完成相应的操作。
简化使用队列及消息传递的复杂性，提供方便的调用方法。其中最重要的函数是：

/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg); // 1、利用 Calback 函数处理消息
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) { // 2、利用mCallback处理消息
return;
}
}
handleMessage(msg); // 3、利用子类处理消息，这里最常用的方法，直接重载handleMessage函数
}
}

那么这几者的关系是怎么样的呢？

一个Activity中可以创建多个工作线程或者其他的组件，如果这些线程或者组件把他们的消息放入Activity的主线程消息队列，那么该消息就会在主线程中处理了。

还有一个问题就是Looper和Handler的同步关系如何处理，在android由HandlerThread类进行解决了。

public Looper getLooper() {
if (!isAlive()) {
return null;
}

// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait(); // 如果新线程还未创建Looper对象，则等待
} catch (InterruptedException e) {
}
}
}
return mLooper;
}

新线程创建运行run函数创建Looper对象：
public void run() {
mTid = Process.myTid();
Looper.prepare();// 这里会创建程的Looper对象
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll(); // ok,创建好了则通知，最后调用Looper.loop()进入消息循环
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}

这里利用 notifyAll / wait 轻检解决此问题了，所以多多使用用HanlderThread类完成多线程同步问题吧。

培训时学员提出的疑问进行补充说明：

每个线程都可以有自己的消息队列和消息循环,一个线程可以存在（当然也可以不存在）一个消息队列和一个消息循环（Looper），特定线程的消息只能分发给本线程，不能进行跨线程，跨进程通讯。

那么除了UI thread(ActivityThread main Looper线程)工作如何运行的呢？
可以参考下 AsyncQueryHandler.java 实现：

private static Looper sLooper = null;

private Handler mWorkerThreadHandler;

   // 工作线程，处理消息,减轻UI thread负担
   protected class WorkerHandler extends Handler {
   public WorkerHandler(Looper looper) {
   super(looper);
   }
   @Override
   public void handleMessage(Message msg) {
   ...
   }
   }

   //1、构造Looper消息处理线程HandlerThread
   public AsyncQueryHandler(ContentResolver cr) {
   super();
   mResolver = new WeakReference<ContentResolver>(cr);
   synchronized (AsyncQueryHandler.class) {
   if (sLooper == null) {
   HandlerThread thread = new HandlerThread("AsyncQueryWorker");

// 这里将会调用到HandlerThread.run()进入到Looper.loop();循环消息处理中

thread.start();

//2、利用thread.getLooper()获取自已的Looper

   sLooper = thread.getLooper();
   }
   }
   //3、并设定给WorkerHandler进行构造绑定其Looper对象
   mWorkerThreadHandler = createHandler(sLooper);
   }

   protected Handler createHandler(Looper looper) {
   return new WorkerHandler(looper);
   }

   //4 利用mWorkerThreadHandler（Handler对象）发送消息
   public void startQuery(int token,...){