Handler源碼是什么

這篇文章主要介紹“Handler源碼是什么”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Handler源碼是什么”文章能幫助大家解決問題。

Handler機制是Android中相當經典的異步消息機制，在Android發展的歷史長河中扮演著很重要的角色，無論是我們直接面對的應用層還是FrameWork層，使用的場景還是相當的多。

分析源碼一探究竟。

從一個常見的用法說起：

private Button mBtnTest;private Handler mTestHandler = new Handler(){   @Override
   public void handleMessage(Message msg) {       switch (msg.what){           case 1:
               mBtnTest.setText("收到消息1");
       }
   }
};@Overrideprotected void onCreate(final Bundle savedInstanceState) {   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);
   mBtnTest = (Button) findViewById(R.id.btn_test);   new Thread(new Runnable() {       @Override
       public void run() {           try {
               Thread.sleep(3000);
               mTestHandler.sendEmptyMessage(1);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }).start();
}

在對某件實物進一步了解之前，我們要先對該事物的價值意義有一個理解，即他是做什么的，再明白事物產生或發生時做了什么，結束時又會有什么樣的結果。

我們要討論研究的是這個過程到底經歷了什么，是發生什么因，再經歷什么產生這個果。

當調用Handler發送消息相關方法時，會把這個消息發送到哪兒去？從上面的示例代碼中可以看到消息最終還是會回到Handler手上，由他自己處理。我們要搞清楚的就是這個消息由發到收的過程。

消息會發送到哪兒去？

mTestHandler.sendEmptyMessage(1);

我們追隨sendEmptyMessage()方法下去：

Handler無論以何種方式發送何種消息,都會經過到sendMessageAtTime()方法：

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
   MessageQueue queue = mQueue;   if (queue == null) {
       RuntimeException e = new RuntimeException(               this + " sendMessageAtTime() called with no mQueue");
       Log.w("Looper", e.getMessage(), e);       return false;
   }   return enqueueMessage(queue, msg, uptimeMillis);
}

而此方法會先判斷當前Handler的mQueue對象是否為空，再調用enqueueMessage()方法，從字面意思不難理解是將該消息入隊保存起來。再看enqueueMessage()方法：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
   msg.target = this;   if (mAsynchronous) {
       msg.setAsynchronous(true);
   }   return queue.enqueueMessage(msg, uptimeMillis);
}public final class Message implements Parcelable {   //....
   Handler target;
}

該方法會先將Message和當前Handler綁定起來，不難理解當需要處理Message時直接甩給綁定他的Handler就是了。再調用queue.enqueueMessage()方法正式入隊，而queue對象到底是一個什么樣的對象？由單向鏈表實現的消息隊列。queue.enqueueMessage()方法就是遍歷鏈表將消息插入表尾保存起來，而從queue取消息就是把表頭的Message拿出來。

接著來搞清楚queue他是何時怎樣創建的？來看Handler的構造函數。

public Handler(Callback callback, boolean async) {
   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 = callback;
   mAsynchronous = async;
}

Handler的構造方法會先調用Looper.myLooper()方法看能不能獲取一個Looper對象，如果獲取不到程序就直接蹦了。再從該Looper對象中獲取我們需要的消息隊列。

Looper到底是一個怎樣的對象，有這怎樣的身份，在Handler機制中扮演這怎樣的角色？來看myLooper()方法：

public static @Nullable Looper myLooper() {   return sThreadLocal.get();
}

myLooper()方法會直接就從sThreadLocal對象中獲取Looper，而sThreadLocal是一個ThreadLocal類對象，而ThreadLocal類說白了就是通過他存儲的對象是線程私有的。

static final ThreadLocal sThreadLocal = new ThreadLocal();

調用get()方法直接從ThreadLocal中獲取Looper，接下來就得看是何時set()將Loooper對象保存到ThreadLocal中去的。Looper.prepare()方法：

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));
}private Looper(boolean quitAllowed) {
   mQueue = new MessageQueue(quitAllowed);
   mThread = Thread.currentThread();
}

從這段源碼可以看出，Looper不僅是線程私有的還是唯一不可替換。Looper對象創建時會初始化MessageQueue()對象，正是我們需要的隊列。
之所以最上面的示例代碼中我們并沒有調用prepare()方法初始化Looper，程序也沒有崩潰，那是因為在ActivityThread的Main方法中就已經初始化了Looper對象。

public final class ActivityThread {   //......
   public static void main(String[] args) {
       Looper.prepareMainLooper();
   }   //......}

到此我們算是明白消息會發送到哪兒去了，現在就要知道的是怎么取出消息交給Handler處理的。

首先MessageQueue封裝有完整的添加(入隊)和獲取/刪除(出隊)方法，MessageQueeue.next()方法將鏈表當中表頭第一個消息取出。

Message next() {   //..........
   for (;;) {       if (nextPollTimeoutMillis != 0) {
           Binder.flushPendingCommands();
       }
       nativePollOnce(ptr, nextPollTimeoutMillis);       synchronized (this) {           final long now = SystemClock.uptimeMillis();
           Message prevMsg = null;
           Message msg = mMessages;           if (msg != null && msg.target == null) {               do {
                   prevMsg = msg;
                   msg = msg.next;
               } while (msg != null && !msg.isAsynchronous());
           }           if (msg != null) {               if (now < msg.when) {
                   nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
               } else {
                   mBlocked = false;                   if (prevMsg != null) {
                       prevMsg.next = msg.next;
                   } else {
                       mMessages = msg.next;
                   }
                   msg.next = null;                   if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                   msg.markInUse();                   return msg;
               }
           } else {
               nextPollTimeoutMillis = -1;
           }           if (mQuitting) {
               dispose();               return null;
           }           //............
       }       //..............
   }
}

代碼雖然比較多，我們從第三行和第39行開始說起。next()方法實際是一個死循環，會一直從當前隊列中去取Message，即使當前隊列沒有消息可取，也不會跳出循環，會一直執行，直到能夠從隊列中取到消息next()方法才會執行結束。

其次當Looper調用quit()方法，mQuitting變量為ture時會跳出死循環，next()方法返回null方法也會執行結束。

上面提到在ActivityThread中的main()方法中會初始化Looper,其實在不久之后便會開始從隊列中取消息。

public static void main(String[] args) {   //......
   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"));
   }
   Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
   Looper.loop();   throw new RuntimeException("Main thread loop unexpectedly exited");
}
調用Looper.loop()方法就會開始遍歷取消息。public static void loop() {for (;;) {
   Message msg = queue.next(); // might block
   if (msg == null) {       return;
   }   final Printer logging = me.mLogging;   if (logging != null) {
       logging.println(">>>>> Dispatching to " + msg.target + " " +
               msg.callback + ": " + msg.what);
   }   final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;   final long traceTag = me.mTraceTag;   if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
       Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
   }   final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();   final long end;   try {
       msg.target.dispatchMessage(msg);
       end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
   } finally {       if (traceTag != 0) {
           Trace.traceEnd(traceTag);
       }
   }
}

loop()方法中也是一個死循環，調用queue.nex()方法開始阻塞式取消息，只有手動讓Looper停止，next()方法才會返回null。

取到消息后，調用dispatchMessage()方法把消息交由Handler處理。

msg.target.dispatchMessage(msg);

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

不僅可以給Handler設置回調接口，Message也行。默認情況下會回調handleMessage()方法。

本以為說得差不多了，其實還有一個關鍵的問題。我們是在主線程中執行的loop()方法，死循環為什么沒有造成Activity阻塞卡死？查閱資料Android中為什么主線程不會因為Looper.loop()里的死循環卡死后得知next()方法中會執行一個重要方法。

nativePollOnce(ptr, nextPollTimeoutMillis);

大佬分析得很好，我就不多說了。提一點，我們發送的延時消息，會通過Message字段/變量when，將時長保存下來，延時也是通過這個方法做到的。

Message next() {   final long now = SystemClock.uptimeMillis();   if (msg != null) {       if (now < msg.when) {           // 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 {           //......
       }
   }
}

Handler發送消息會將消息保存到Looper維護的消息隊列MessageQueue中去，而Looper會死循環一直從隊列中取消息，取到消息后會交由Message綁定的Handler回調處理。

關于“Handler源碼是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。