在《Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面》中，我们讲到使用Thread+Handler的方式来实现界面的更新，其实是在非UI线程发送消息到UI线程，通知UI线程进行界面更新，这一篇我们将深入学习Android线程间通讯的实现原理。

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

例子：在介绍原理之前，我们先介绍Android线程通讯的一个例子，这个例子实现点击按钮之后从主线程发送消息"hello"到另外一个名为” CustomThread”的线程。

LooperThreadActivity.java

01 packagecom.zhuozhuo; 02 03 importandroid.app.Activity; 04 importandroid.os.Bundle; 05 importandroid.os.Handler; 06 importandroid.os.Looper; 07 importandroid.os.Message; 08 importandroid.util.Log; 09 importandroid.view.View; 10 importandroid.view.View.OnClickListener; 11 12 publicclassLooperThreadActivityextendsActivity{ 13 /** Called when the activity is first created. */ 14 15 privatefinalintMSG_HELLO =0; 16 privateHandler mHandler; 17 18 @Override 19 publicvoidonCreate(Bundle savedInstanceState) { 20 super.onCreate(savedInstanceState); 21 setContentView(R.layout.main); 22 newCustomThread().start();//新建并启动CustomThread实例 23 24 findViewById(R.id.send_btn).setOnClickListener(newOnClickListener() { 25 26 @Override 27 publicvoidonClick(View v) {//点击界面时发送消息 28 String str ="hello"; 29 Log.d("Test","MainThread is ready to send msg:"+ str); 30 mHandler.obtainMessage(MSG_HELLO, str).sendToTarget();//发送消息到CustomThread实例 31 32 } 33 }); 34 35 } 36 37 38 39 40 41 classCustomThreadextendsThread { 42 @Override 43 publicvoidrun() { 44 //建立消息循环的步骤 45 Looper.prepare();//1、初始化Looper 46 mHandler =newHandler(){//2、绑定handler到CustomThread实例的Looper对象 47 publicvoidhandleMessage (Message msg) {//3、定义处理消息的方法 48 switch(msg.what) { 49 caseMSG_HELLO: 50 Log.d("Test","CustomThread receive msg:"+ (String) msg.obj); 51 } 52 } 53 }; 54 Looper.loop();//4、启动消息循环 55 } 56 } 57 }

main.xml

01 <?xmlversion="1.0"encoding="utf-8"?> 02 <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android" 03 android:orientation="vertical" 04 android:layout_width="fill_parent" 05 android:layout_height="fill_parent" 06 > 07 <TextView 08 android:layout_width="fill_parent" 09 android:layout_height="wrap_content" 10 android:text="@string/hello" 11 /> 12 <Buttonandroid:text="发送消息"android:id="@+id/send_btn"android:layout_width="wrap_content"android:layout_height="wrap_content"></Button> 13 </LinearLayout>

Log打印结果：

原理：

我们看到，为一个线程建立消息循环有四个步骤：

1、 初始化Looper

2、 绑定handler到CustomThread实例的Looper对象

3、 定义处理消息的方法

4、 启动消息循环

下面我们以这个例子为线索，深入Android源代码，说明Android Framework是如何建立消息循环，并对消息进行分发的。

1、 初始化Looper : Looper.prepare()

Looper.java

1 privatestaticfinalThreadLocal sThreadLocal =newThreadLocal(); 2 publicstaticfinalvoidprepare() { 3 if(sThreadLocal.get() !=null) { 4 thrownewRuntimeException("Only one Looper may be created per thread"); 5 } 6 sThreadLocal.set(newLooper()); 7 }

一个线程在调用Looper的静态方法prepare()时，这个线程会新建一个Looper对象，并放入到线程的局部变量中，而这个变量是不和其他线程共享的(关于ThreadLocal的介绍)。下面我们看看Looper()这个构造函数：

Looper.java

1 finalMessageQueue mQueue; 2 privateLooper() { 3 mQueue =newMessageQueue(); 4 mRun =true; 5 mThread = Thread.currentThread(); 6 }

可以看到在Looper的构造函数中，创建了一个消息队列对象mQueue，此时，调用Looper. prepare()的线程就建立起一个消息循环的对象(此时还没开始进行消息循环)。

2、 绑定handler到CustomThread实例的Looper对象 : mHandler= new Handler()

Handler.java

01 finalMessageQueue mQueue; 02 finalLooper mLooper; 03 publicHandler() { 04 if(FIND_POTENTIAL_LEAKS) { 05 finalClass<?extendsHandler> klass = getClass(); 06 if((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && 07 (klass.getModifiers() & Modifier.STATIC) ==0) { 08 Log.w(TAG,"The following Handler class should be static or leaks might occur: "+ 09 klass.getCanonicalName()); 10 } 11 } 12 13 mLooper = Looper.myLooper(); 14 if(mLooper ==null) { 15 thrownewRuntimeException( 16 "Can't create handler inside thread that has not called Looper.prepare()"); 17 } 18 mQueue = mLooper.mQueue; 19 mCallback =null; 20 }

Handler通过mLooper = Looper.myLooper();绑定到线程的局部变量Looper上去，同时Handler通过mQueue =mLooper.mQueue;获得线程的消息队列。此时，Handler就绑定到创建此Handler对象的线程的消息队列上了。

3、定义处理消息的方法：Override public void handleMessage (Message msg){}

子类需要覆盖这个方法，实现接受到消息后的处理方法。

4、启动消息循环 ： Looper.loop()

所有准备工作都准备好了，是时候启动消息循环了!Looper的静态方法loop()实现了消息循环。

Looper.java

01 publicstaticfinalvoidloop() { 02 Looper me = myLooper(); 03 MessageQueue queue = me.mQueue; 04 05 // Make sure the identity of this thread is that of the local process, 06 // and keep track of what that identity token actually is. 07 Binder.clearCallingIdentity(); 08 finallongident = Binder.clearCallingIdentity(); 09 10 while(true) { 11 Message msg = queue.next();// might block 12 //if (!me.mRun) { 13 // break; 14 //} 15 if(msg !=null) { 16 if(msg.target ==null) { 17 // No target is a magic identifier for the quit message. 18 return; 19 } 20 if(me.mLogging!=null) me.mLogging.println( 21 ">>>>> Dispatching to "+ msg.target +" " 22 + msg.callback +": "+ msg.what 23 ); 24 msg.target.dispatchMessage(msg); 25 if(me.mLogging!=null) me.mLogging.println( 26 "<<<<< Finished to "+ msg.target +" " 27 + msg.callback); 28 29 // Make sure that during the course of dispatching the 30 // identity of the thread wasn't corrupted. 31 finallongnewIdent = Binder.clearCallingIdentity(); 32 if(ident != newIdent) { 33 Log.wtf("Looper","Thread identity changed from 0x" 34 + Long.toHexString(ident) +" to 0x" 35 + Long.toHexString(newIdent) +" while dispatching to " 36 + msg.target.getClass().getName() +" " 37 + msg.callback +" what="+ msg.what); 38 } 39 40 msg.recycle(); 41 } 42 } 43 }

while(true)体现了消息循环中的“循环“，Looper会在循环体中调用queue.next()获取消息队列中需要处理的下一条消息。当msg != null且msg.target != null时，调用msg.target.dispatchMessage(msg);分发消息，当分发完成后，调用msg.recycle();回收消息。

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

Handler.java

01 publicvoiddispatchMessage(Message msg) { 02 if(msg.callback !=null) { 03 handleCallback(msg); 04 }else{ 05 if(mCallback !=null) { 06 if(mCallback.handleMessage(msg)) { 07 return; 08 } 09 } 10 handleMessage(msg); 11 } 12 }

可见，当msg.callback== null 并且mCallback == null时，这个例子是由handleMessage(msg);处理消息，上面我们说到子类覆盖这个方法可以实现消息的具体处理过程。

总结：从上面的分析过程可知，消息循环的核心是Looper，Looper持有消息队列MessageQueue对象，一个线程可以把Looper设为该线程的局部变量，这就相当于这个线程建立了一个对应的消息队列。Handler的作用就是封装发送消息和处理消息的过程，让其他线程只需要操作Handler就可以发消息给创建Handler的线程。由此可以知道，在上一篇《Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面》中，UI线程在创建的时候就建立了消息循环(在ActivityThread的public static final void main(String[] args)方法中实现)，因此我们可以在其他线程给UI线程的handler发送消息，达到更新UI的目的。