Android消息机制

在Android中，主线程UI线程不是线程安全的，对UI的更新只能在UI线程中执行，在工作线程中执行UI更新操作，会抛出android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.  错误。

为了实现工作线程对UI线程的操作，以及线程间通信，Android中设计了一套消息机制。

Android消息机制主要有Looper、Handler、Message和MessageQueue几个类组成。

借用下别人的图片，各组件的关系如下：

Looper

每个线程只能有一个Looper（其实Looper是一个ThreadLocal对象），Looper主要实现对MessageQueue中的Message信息的消费。

UI线程启动的时候，默认绑定了一个Looper。

对于工作线程可通过Looper.prepare()和Looper.loop()简单的两步，把线程变为LooperThread，实现线程对消息的消费。并为工作线程实例化Handler对象，用于消息的发送和处理。

Looper.prepare()静态方法：

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

Looper private的构造器：

final MessageQueue mQueue;private Looper() {mQueue = new MessageQueue();mRun = true;mThread = Thread.currentThread();}

Looper初始化的时候，会初始化本线程对应的MessageQueue。

Lopper.loop()静态方法：

public static final void loop() {           Looper me = myLooper();           MessageQueue queue = me.mQueue;                           // Make sure the identity of this thread is that of the local process,           // and keep track of what that identity token actually is.           Binder.clearCallingIdentity();           final long ident = Binder.clearCallingIdentity();                           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);                   if (me.mLogging!= null) me.mLogging.println(                           "<<<<< Finished to    " + msg.target + " "                       + msg.callback);                                           // Make sure that during the course of dispatching the                   // identity of the thread wasn't corrupted.                   final long newIdent = Binder.clearCallingIdentity();                   if (ident != newIdent) {                       Log.wtf("Looper", "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();               }           }       }

msg.target是生成消息 的handler对象，表示需要处理这个消息的handler对象。Handler的void dispatchMessage(Message msg)方法见下节。

Looper可以通过静态方法getMainLooper()获取UI线程的Looper对象，通过静态方法myLooper()，获取本线程的Looper对象。

Handler

Handler负责对信息的发送和处理，工作线程可以引用UI线程的Handler实例对象，通过post、postDelayed和sendMessage方法，把消息发送到MessageQueue中。

其中post*方法，传递的为Runnable对象，Runnable对象被封装为Message的callback属性，所以最终发送到MessageQueue中的还是Message对象。

Handler通过覆复写handleMessage方法，作为处理Message的回调方法，实现对Message的处理。

消息处理步骤：

• Looper在消费Message的时候，先判断Message中是否有callback方法，如果有，调用callback，处理消息。
• 如果Handler中有mCallback方法，则调用该方法处理消息。
• 否则，调用handleMessage方法处理消息。

一个线程可以有多个Handler对象，同一个Handler对象发送的Message，由对象自身的handleMessage方法进行处理。

handler.despatchMessage实例方法：

public void dispatchMessage(Message msg) {            if (msg.callback != null) {                handleCallback(msg);            } else {                if (mCallback != null) {                    if (mCallback.handleMessage(msg)) {                        return;                    }                }                handleMessage(msg);            }    }

在工作线程中，需要向UI线程发送消息是，不一定要在UI线程中建立Handler对象，并传递到工作现在。

在工作线程中，可以通过Looper.getMainLooper()获取到UI线程的Looper对象，并通过此Looper对象，实例化Handler对象，绑定到UI线程的Looper和MessageQueue。

class MyThread extends Thread{       public void run(){  Looper looper = Looper.getMainLooper(); //主线程的Looper对象  //这里以主线程的Looper对象创建了handler，  //所以，这个handler发送的Message会被传递给主线程的MessageQueue。  handler = new MyHandler(looper);  //构建Message对象  //第一个参数：是自己指定的message代号，方便在handler选择性地接收  //第二三个参数没有什么意义  //第四个参数需要封装的对象  Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");   handler.sendMessage(msg); //发送消息              }  } 

Message

Message是消息的载体，Message中有String arg1、String arg2、Object obj、int what等几个属性，用户传递简单参数。复杂参数则使用Bundle传递。

Message可以通过静态方法Message.obtain()和实例方法handler.obtainMessage()等方法获取，可以实现对Message对象的复用。通过实例方法message.cycle()，实现Message的回收复用。

实例方法message.sendToTarget()方法等同于实例方法handler.sendMessage()

MessageQueue

MessageQueue是和Looper一一关联的对象，通过消息队列机制对消息进行存储。