一、Handler介紹

  在android開發的過程中，經常需要對ＵＩ進行更新操作。但是在子執行緒中對UI進行更新在android中是不允許的，這涉及到了執行緒安全問題，因此更新UI只能在主執行緒（UI執行緒）中進行。但是如果將耗時操作放在了UI執行緒中會帶來程式體驗上卡頓甚至ANR等問題。然而通過Android的Handler機制能夠很好解決此類問題。
  Handler為UI的非同步跟新提供了一個很好的方式。Handler的主要作用是在子執行緒中進行耗時操作，將得到的資料通過handler 傳送個主執行緒（UI執行緒）主執行緒根據結果進行UI的更新。

二、Handler相關方法介紹

  在使用Handler的時，通常需要將Handler訊息傳送給主執行緒，常用的方法如下：
  sendEmptyMessage(int what):傳送空訊息
   boolean sendEmptyMessageDelayed(int what,long delayMillis):指定多少毫秒之後傳送空訊息
  sendMessage(Message msg):立即傳送訊息
  sendMessageDelayed(Message msg,long delayMillis):指定多少毫秒之後傳送訊息
  obtainMessage()：從訊息佇列中返回一個Message
  sendMessageAtFrontOfQueue(Message msg):將message插入到messageQueue前列。
方法還有很多，此處不一一列舉。

三、Hanlder使用例項

  在使用Hanlder的時候通常需要以下幾個步驟；

private Handler mHandler;

        mHandler = new Handler() {
            @SuppressWarnings("unchecked")
            public void handleMessage(Message msg) {
                switch(msg.what) {
                case XX:
                需要執行的程式碼
                    break
 
;
                case XX:
                需要執行的程式碼
                    break;
                default:
                    break;
                }
            }
        };

 Message msg = new Message(); 
 msg.what = XXX;
mhandler.sendMessage();

總的說來分為了三步，先新建一個Handler的例項，再根據需求重寫了handleMessage(Message msg)方法，最後通過mHandler傳送訊息交由handleMessage(Message msg)處理。

四 Handler實現原理

Handler的實現與三個元件相關：
1.Message:Handler接收和處理的訊息物件
2.Looper：每個執行緒只能擁有一個Looper.它的loop方法負責讀取MessageQueue中的訊息，
讀到資訊之後就把訊息交給傳送該訊息的Handler進行處理。
3.MessageQueue:訊息佇列，它採用先進先出的方式來管理Message.
  在一個activity中，程式自動的幫我們綁定了一個loop到主執行緒。在ActivityThread.java可以看到：

public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();

           ......

        // Make sure TrustedCertificateStore looks in the right place for CA certificates

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();
                .......
    }

因此，我們可以在UI執行緒中直接使用Handler。如果需要在自己執行緒中使用handler 則需要自己向執行緒繫結looper，具體實現在後面文章中詳細解釋。
現在我們來先看看 Looper，Message ，Handler他們之間的關係。
Message:訊息的載體。可以攜帶訊息種類、資料等資訊。
（1）public int what：變數，用於定義此Message屬於何種操作
（2）public Object obj：變數，用於定義此Message傳遞的資訊資料，通過它傳遞資訊
（3）public int arg1：變數，傳遞一些整型資料時使用
（4）public int arg2：變數，傳遞一些整型資料時使用
Looper：每一個執行緒只能有一個Looper，它負責這從MessageQueue中取出Message並將其分發給Handler處理。下面來看看Looper是怎麼執行的。

public final class Looper {

    private static final String TAG = "Looper";
......
    final MessageQueue mQueue;
    final Thread mThread;
    private Printer mLogging;

    public static void prepare() {
        prepare(true);
    }

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

    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;
        ......
/*迴圈裡，不斷從MessageQueue中取出msg ，根據msg所攜帶的資訊進行分發*/
        for (;;) {
            Message msg = queue.next(); // 取出msg
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);//分發訊息給handler 處理

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

Handler 類主要用於處理自己發出的msg，而msg又在loop中進行取出。Handler原始碼如下：

 public Handler(Callback callback, boolean async) {
        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();//handler與looper繫結
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;//handler與msgqueue繫結
        mCallback = callback;
        mAsynchronous = async;
    }

綜上，在一個執行緒中綁定了一個looper後即成為了Looper執行緒。這looper執行緒中，可以新建Handler ，再通過handler例項向messageQueue中放入訊息，放入的訊息由looper取出再分發給相應的Handler處理。
（下一篇將寫怎麼去自建一個looperThread ，HanderThread ，以及hander.obtain()的優點）。