Android?Handler源碼分析

本篇內(nèi)容主要講解“Android Handler源碼分析”，感興趣的朋友不妨來(lái)看看。本文介紹的方法操作簡(jiǎn)單快捷，實(shí)用性強(qiáng)。下面就讓小編來(lái)帶大家學(xué)習(xí)“Android Handler源碼分析”吧!

1.android 消息循環(huán)有4個(gè)重要的類Handler、Message、Looper、MessageQueue

handler 用來(lái)發(fā)送、處理消息。

Message 是消息的載體。

MessageQueue 是一個(gè)消息隊(duì)列，既然是隊(duì)列，就有入隊(duì)、出隊(duì)的處理。

Looper 創(chuàng)建一個(gè)消息循環(huán)。不斷的從MessageQueue中讀取消息、并分發(fā)給相應(yīng)的Handler進(jìn)行處理。

2.我們都知道m(xù)ain函數(shù)是Java程序的入口，android程序也不例外。

android App的唯一入口就是ActivityThread中的 main函數(shù)。 這個(gè)函數(shù)是由Zygote創(chuàng)建app進(jìn)程后 通過反射的方式調(diào)用的。

當(dāng)一個(gè)App啟動(dòng)時(shí)，會(huì)先執(zhí)行這個(gè)main方法，在ActivityThread，main方法中，

      public static void main(String[] args) {
          //創(chuàng)建一個(gè)消息循環(huán)
          Looper.prepareMainLooper();
          //創(chuàng)建ActivityThread對(duì)象
          ActivityThread thread = new ActivityThread();
          //創(chuàng)建Application、啟動(dòng)MainActivity
          thread.attach(false, startSeq);
          //使消息循環(huán)奔跑起來(lái)
          Looper.loop();
          //拋了一個(gè)異常 主線程的Looper 意外退出了，
          //所以loop中的for循環(huán)要阻塞在這里，一旦main函數(shù)執(zhí)行完畢，進(jìn)程也就退出了。
          //并且一直要提取消息，處理消息。
          throw new RuntimeException("Main thread loop unexpectedly exited");
      }

3. 首先看Looper是如何創(chuàng)建的。

 Looper.prepareMainLooper();
    public static void prepareMainLooper() {
        prepare(false);
        //同步方法保證一個(gè)sMainLooper 只被賦值一次。
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
    //創(chuàng)建一個(gè)Looper對(duì)象，并保存在了 sThreadLocal中。關(guān)于ThreadLocal，也是很重要的一個(gè)知識(shí)點(diǎn)。
     private static void prepare(boolean quitAllowed) {
        //一個(gè)線程只能有一個(gè)Looper，
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
     }
      public static @Nullable Looper myLooper() {
            return sThreadLocal.get();
      }
   //在Looper中創(chuàng)建了MessageQueue
   private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
   }

至此，創(chuàng)建的代碼執(zhí)行完畢。

總結(jié)一句話就是，app啟動(dòng)時(shí)，會(huì)創(chuàng)建Looper，并且保證一個(gè)線程只能創(chuàng)建一個(gè)Looper。

創(chuàng)建Looper的同時(shí)，也創(chuàng)建的消息隊(duì)列 MessageQueue。這些都是消息循環(huán)的準(zhǔn)備工作。

通過Looper.loop，這個(gè)消息循環(huán)就跑起來(lái)了。

 Looper.loop();
    /**
    * Run the message queue in this thread.
    */
     public static void loop() {
        for (; ; ) {
            //從消息循環(huán)中提取消息。消息時(shí)會(huì)阻塞在這里。
            Message msg = queue.next(); // might block
            //target-->Handler.Msg持有handler的引用。
            msg.target.dispatchMessage(msg);
        }
    }

4.在MessageQueue中enqueueMessage()插入消息、next()提取消息方法。

 插入消息
    //Message.obtain()從Message消息緩存池內(nèi)獲得一個(gè)消息。
    handler.sendMessage(Message.obtain());
    public final boolean sendMessage(Message msg){
        return sendMessageDelayed(msg, 0);
    }
    //我們發(fā)送的延遲消息，寫入到消息循環(huán)中都是一個(gè)時(shí)間戳，當(dāng)前時(shí)間+延遲時(shí)間，未來(lái)某個(gè)時(shí)間。
   public final boolean sendMessageDelayed(Message msg, long delayMillis){
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
   }
    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
           MessageQueue queue = mQueue;
           return enqueueMessage(queue, msg, uptimeMillis);
    }
     private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            //this==handler,在這里給message.target賦值了handler。
            msg.target = this;
            if (mAsynchronous) {
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
     }

     //在MessageQueue中用一個(gè)單線鏈表來(lái)保存消息。
     //在這個(gè)消息的單鏈表中，是按消息執(zhí)行的時(shí)間先后，從小到大排序的。
     //mMessages 是這個(gè)單鏈表的第一個(gè)消息。
     boolean enqueueMessage(Message msg, long when) {
          //通過sendMessage并不能發(fā)送handler==null的消息。
         if (msg.target == null) {
              throw new IllegalArgumentException("Message must have a target.");
          }
         synchronized (this) {
             msg.markInUse();
             msg.when = when;
             //將鏈表中第一個(gè)消息賦值給p
             Message p = mMessages;
             boolean needWake;
             //如果p==null說明消息列表中沒有要被執(zhí)行的消息。
             //如果when==0說明新新添加的消息要被馬上執(zhí)行，所以要排在列表的頭部
             //如果when<p.when，說明新添加的消息，比消息隊(duì)列第一個(gè)消息要先執(zhí)行，所以也要放在頭部
             if (p == null || when == 0 || when < p.when) {
                 // New head, wake up the event queue if blocked.
                 //將原來(lái)的頭部消息賦值給新消息的next
                 msg.next = p;
                 //將新加的消息賦值給mMessage。因?yàn)閙Messages這個(gè)變量用來(lái)保存消息列表的第一個(gè)消息。
                 mMessages = msg;
             } else {//如果when>=p.when，則需要遍歷消息隊(duì)列，將新添加的消息插入到隊(duì)列中間，
                 Message prev;
                 for (;;) {
                     prev = p;//把當(dāng)前的賦值給前一個(gè)
                     p = p.next;//把下一個(gè)賦值給當(dāng)前的
                     //如果p==null說明已經(jīng)遍歷到了鏈表末尾。
                     //如果新增的消息時(shí)間小于了p的when。那么這個(gè)消息應(yīng)該插入到prev之后，p之前。
                     if (p == null || when < p.when) {
                         break;
                     }
                 }
                 //新增消息在p之前，prev之后
                 msg.next = p; // invariant: p == prev.next
                 prev.next = msg;
             }
         }
         return true;
   }

提取消息：

  Message next() {
           int nextPollTimeoutMillis = 0;
           for (;;) {
               if (nextPollTimeoutMillis != 0) {
                   Binder.flushPendingCommands();
               }
               //開始休眠，nextPollTimeoutMillis下次被喚醒的時(shí)間
               //如果是-1則一直休眠，直到有新的消息再喚醒消息隊(duì)列。
               nativePollOnce(ptr, nextPollTimeoutMillis);
               synchronized (this) {
                   // Try to retrieve the next message.  Return if found.
                   //開始遍歷消息隊(duì)列，返回找到的消息。
                   final long now = SystemClock.uptimeMillis();
                   Message prevMsg = null;
                   //消息隊(duì)列，頭部消息
                  //如果msg！=null,但是msg.target==null,sendMessage中，是不允許發(fā)送handler為null的消息的。
                   //target==null的消息是系統(tǒng)發(fā)送的，先發(fā)送一個(gè)同步屏障消息，再發(fā)送直到isAsynchronous = true的異步消息。
				   //這樣做的目的就保證了這個(gè)異步消息有更高優(yōu)先級(jí)被執(zhí)行，先從消息隊(duì)列中提取。
                   if (msg != null && msg.target == null) {
                       // Stalled by a barrier.  Find the next asynchronous message in the queue.
                       do {
                           prevMsg = msg;
                           msg = msg.next;
                       } while (msg != null && !msg.isAsynchronous());//直到isAsynchronous = true，也就是找到了同步屏障的異步消息
                   }
                   }
                   if (msg != null) {
                       if (now < msg.when) {//當(dāng)前時(shí)間小于消息執(zhí)行的時(shí)間，記錄一下差值
                           // Next message is not ready.  Set a timeout to wake up when it is ready.
                           nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                       } else {//如果當(dāng)前時(shí)間，不小于取到消息的執(zhí)行時(shí)間，則從消息隊(duì)列中提取出該消息，并返回出去
                           // Got a message.
                           mBlocked = false;
                           if (prevMsg != null) {
                               //將前一個(gè)消息的下一個(gè)消息指向，當(dāng)前消息的下一個(gè)。
                               prevMsg.next = msg.next;
                           } else {
                               //如果前一個(gè)消息是null，說明當(dāng)前就是消息頭，
                               //將消息隊(duì)列頭部消息指向當(dāng)前提取出消息的下一個(gè)消息。
                               mMessages = msg.next;
                           }
                           //將找到的消息的下一個(gè)賦值null，和原來(lái)的消息隊(duì)列脫離關(guān)系。
                           msg.next = null;
                           if (false) Log.v("MessageQueue", "Returning message: " + msg);
                           return msg;
                       }
                   } else {//如果msg==null
                       // No more messages.
                       nextPollTimeoutMillis = -1;
                   }
               }
           }
       }

handler會(huì)涉及到native的代碼。在native層使用的epoll機(jī)制，這個(gè)后面在深入分享。

  //同步屏障消息
    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            //發(fā)送一個(gè)同步屏障消息
            mTraversalBarrier = mHandler.getLooper().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        }
    }

5. 至此，整個(gè)消息循環(huán)大體的流程已經(jīng)完成。但是關(guān)于handler的面試題很多。

比如為啥handler會(huì)導(dǎo)致Activity內(nèi)存泄漏？如何解決？

內(nèi)存泄漏的本質(zhì)就是長(zhǎng)聲明周期對(duì)象持有短聲明周期對(duì)象的引用，導(dǎo)致短聲明周期對(duì)象，不再使用但內(nèi)存卻無(wú)法被回收。

我們知道handler作為Activity的內(nèi)部類，持有外部類的引用，所以整個(gè)引用鏈?zhǔn)?/p>

Activity-->handler-->Message-->MessageQueue.

當(dāng)activity退出后，如果消息為來(lái)的及處理，就有可能會(huì)導(dǎo)致Activity無(wú)法被GC回收，從而導(dǎo)致內(nèi)存泄漏。

handler.post(),發(fā)送的消息執(zhí)行在子線程還是主線程？

下面來(lái)看消息池。消息池也是一個(gè)單項(xiàng)鏈表，長(zhǎng)度是50.

靜態(tài)對(duì)象sPool就是消息隊(duì)列的頭部Message。

每次獲取消息時(shí)，都會(huì)返回消息池中第一個(gè)對(duì)象。

  Message.obtain()
     private static Message sPool;
     private static final int MAX_POOL_SIZE = 50;
     public static Message obtain() {
            synchronized (sPoolSync) {
                if (sPool != null) {
                    Message m = sPool;
                    sPool = m.next;
                    m.next = null;
                    m.flags = 0; // clear in-use flag
                    sPoolSize--;
                    return m;
                }
            }
            return new Message();
      }

到此，相信大家對(duì)“Android Handler源碼分析”有了更深的了解，不妨來(lái)實(shí)際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！