Android異步處理：Handler+Looper+MessageQueue深刻詳解

轉載自：http://blog.csdn.net/mylzc/article/details/6771331，在原文基礎上修改整理再發布。

概述：Android使用消息機制實現線程間的通訊，線程經過Looper創建本身的消息循環，MessageQueue是FIFO的消息隊列，Looper負責從MessageQueue中取出消息，而且分發到消息指定目標Handler對象。Handler對象綁定到線程的局部變量Looper，封裝了發送消息和處理消息的接口。

例子：在介紹原理以前，咱們先介紹Android線程通信的一個例子，這個例子實現點擊按鈕以後從主線程發送消息"hello"到另一個名爲」 CustomThread」的線程。

Log打印結果：

原理：

咱們看到，爲一個線程創建消息循環有四個步驟：

一、  初始化Looper

二、  綁定handler到CustomThread實例的Looper對象

三、  定義處理消息的方法

四、  啓動消息循環

下面咱們以這個例子爲線索，深刻Android源代碼，說明Android Framework是如何創建消息循環，並對消息進行分發的。

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

Looper.java

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的靜態方法prepare()時，這個線程會新建一個Looper對象，並放入到線程的局部變量中，而這個變量是不和其餘線程共享的（關於ThreadLocal的介紹）。下面咱們看看Looper()這個構造函數：

Looper.java

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

能夠看到在Looper的構造函數中，建立了一個消息隊列對象mQueue，此時，調用Looper. prepare()的線程就創建起一個消息循環的對象（此時還沒開始進行消息循環）。

二、  綁定handler到CustomThread實例的Looper對象 : mHandler= new Handler()

Handler.java

final MessageQueue mQueue;
 final Looper mLooper;
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());
            }
        }

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

Handler經過mLooper = Looper.myLooper();綁定到線程的局部變量Looper上去，同時Handler經過mQueue =mLooper.mQueue;得到線程的消息隊列。此時，Handler就綁定到建立此Handler對象的線程的消息隊列上了。

三、定義處理消息的方法：Override public void handleMessage (Message msg){}

     子類須要覆蓋這個方法，實現接受到消息後的處理方法。

四、啓動消息循環 ： Looper.loop()

      全部準備工做都準備好了，是時候啓動消息循環了！Looper的靜態方法loop()實現了消息循環。

Looper.java

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

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

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

可見，當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的目的。

完整代碼：

package com.xsjayz.looper;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class LooperThreadActivity extends Activity {

	private final int MSG_HELLO = 0;
	private Handler handler;
	private Button button;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		button = (Button) findViewById(R.id.send_btn);

		new CustomThread().start();

		// 點擊按鈕時發送消息
		button.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				String str = "hello";
				Log.d("Test", "MainThread is ready to send msg0000000000:"
						+ str);
				// 發送消息到CustomThread實例
				handler.obtainMessage(MSG_HELLO, str).sendToTarget();
			}
		});
	}

	/**
	 * 創建消息循環的步驟
	 */
	class CustomThread extends Thread {
		@Override
		public void run() {
			// 一、初始化Looper
			Looper.prepare();
			// 二、綁定handler到CustomThread實例的Looper對象
			handler = new Handler() {
				// 三、定義處理消息的方法
				public void handleMessage(Message msg) {
					switch (msg.what) {
					case MSG_HELLO:
						Log.d("Test", "CustomThread receive msg1111111111:"
								+ (String) msg.obj);
					}
				}
			};
			// 四、啓動消息循環
			Looper.loop();
		}
	}
}

佈局文件：main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

    <Button
        android:id="@+id/send_btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/send_msg" >
    </Button>

</LinearLayout>