Android Handler機制-Looper、Handler、MessageQueue、Message的關係

時間  2020-06-21
標籤 android handler 機制 looper messagequeue message 關係 欄目 Android 简体版
原文   原文鏈接

1、概述

Handler是Android中處理異步消息的機制。Looper、Handler、MessageQueue、Message歸納來講就是：Looper負責的就是建立一個MessageQueue，而後進入一個無限循環體不斷從該MessageQueue中讀取消息Message，而後回調相應的消息處理函數，而消息的建立者就是一個或多個Handler，執行完成一個消息後則繼續循環。android

2、MessageQueue詳解

消息隊列MessageQueue就是存放消息的隊列。那隊列中存儲的消息是什麼呢？假設咱們在UI界面上單擊了某個按鈕，而此時程序又剛好收到了某個廣播事件，那咱們如何處理這兩件事呢？ 由於一個線程在某一時刻只能處理一件事情，不能同時處理多件事情，因此咱們不能同時處理按鈕的單擊事件和廣播事件，咱們只能挨個對其進行處理，只要挨個處理就要有處理的前後順序。爲此Android把UI界面上單擊按鈕的事件封裝成了一個Message，將其放入到MessageQueue裏面去，即將單擊按鈕事件的Message入棧到消息隊列中，而後再將廣播事件的封裝成以Message，也將其入棧到消息隊列中。也就是說一個Message對象表示的是線程須要處理的一件事情，消息隊列就是一堆須要處理的Message的池。線程Thread會依次取出消息隊列中的消息，依次對其進行處理。spring

MessageQueue中有兩個比較重要的方法，一個是enqueueMessage方法，一個是next方法。enqueueMessage方法用於將一個Message放入到消息隊列MessageQueue中，next方法是從消息隊列MessageQueue中阻塞式地取出一個Message。bash

3、Looper詳解

消息隊列MessageQueue只是存儲Message的地方，真正讓消息隊列循環起來的是Looper，這就比如消息隊列MessageQueue是個水車，那麼Looper就是讓水車轉動起來的河水，若是沒有河水，那麼水車就是個靜止的擺設，沒有任何用處，Looper讓MessageQueue動了起來。多線程

Looper是用來使線程中的消息循環起來的。默認狀況下當咱們建立一個新的線程的時候，這個線程裏面是沒有消息隊列MessageQueue的。爲了可以讓線程可以綁定一個消息隊列，咱們須要藉助於Looper：首先咱們要調用Looper的prepare方法，而後調用Looper的loop方法。異步

（一）prepare()方法

public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(true));
複製代碼

sThreadLocal是一個ThreadLocal對象，能夠在一個線程中存儲變量。能夠看到，將一個Looper的實例放入了ThreadLocal，而且先判斷了sThreadLocal.get是否爲null，不然拋出異常。這也就說明了Looper.prepare()方法不能被調用兩次，同時也保證了一個線程中只有一個Looper實例。async

（二）構造函數

上面的代碼執行了Looper的構造函數，咱們看一下其代碼：ide

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mRun = true;
        mThread = Thread.currentThread();
}
複製代碼

在構造函數中，建立了一個消息隊列MessageQueue，並將其賦值給其成員字段mQueue,這樣Looper也就與MessageQueue經過成員字段mQueue進行了關聯。函數

（三）loop()方法

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;
        
        // 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();
 
        for (;;) {
            Message msg = queue.next(); // might block
            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);
 
            if (logging != null) {
                logging.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(TAG, "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(); } } 複製代碼

上面有幾行代碼是關鍵代碼:oop

1. final Looper me = myLooper();post

myLooper()方法直接返回了sThreadLocal存儲的Looper實例，若是me爲null則拋出異常，也就是說looper方法必須在prepare方法以後運行。

final Looper me = myLooper();
if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
複製代碼
public static Looper myLooper() {
    return sThreadLocal.get();
}
複製代碼

2. final MessageQueue queue = me.mQueue;

拿到該looper實例中的消息隊列mQueue。變量me是經過靜態方法myLooper()得到的當前線程所綁定的Looper，me.mQueue是當前線程所關聯的消息隊列。

3. for (;;)

進入了循環。咱們發現for循環沒有設置循環終止的條件，因此這個for循環是個無限循環。

4. Message msg = queue.next(); // might block

取出一條消息，若是沒有消息則阻塞。咱們經過消息隊列MessageQueue的next方法從消息隊列中取出一條消息，若是此時消息隊列中有Message，那麼next方法會當即返回該Message，若是此時消息隊列中沒有Message，那麼next方法就會阻塞式地等待獲取Message。

5. msg.target.dispatchMessage(msg);

msg的target屬性是Handler，該代碼的意思是讓Message所關聯的Handler經過dispatchMessage方法讓Handler處理該Message。

6. msg.recycle();

釋放消息佔據的資源。

（四）Looper主要做用

1.與當前線程綁定，保證一個線程只會有一個Looper實例，同時一個Looper實例也只有一個MessageQueue。

2.loop()方法，不斷從MessageQueue中去取消息，交給消息Message的target屬性，即Handler的dispatchMessage去處理。

2、Handler詳解

（一）構造函數

使用Handler以前，咱們都是初始化一個實例，好比用於更新UI線程，咱們會在聲明的時候直接初始化，或者在onCreate中初始化Handler實例。因此咱們首先看Handler的構造方法，看其如何與MessageQueue聯繫上的，它在子線程中發送的消息（通常發送消息都在非UI線程）怎麼發送到MessageQueue中的。

public Handler() {
        this(null, false);
}
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();
        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;
    }
複製代碼

上面有幾行代碼是關鍵代碼:

1. public Handler(Callback callback, boolean async)

Handler.Callback是用來處理Message的一種手段，若是沒有傳遞該參數，那麼就應該重寫Handler的handleMessage方法，也就是說爲了使得Handler可以處理Message，咱們有兩種辦法：

（1）向Hanlder的構造函數傳入一個Handler.Callback對象，並實現Handler.Callback的handleMessage方法。

（2）無需向Hanlder的構造函數傳入Handler.Callback對象，可是須要重寫Handler自己的handleMessage方法。

//在主線程中建立mHandler，因此自動綁定主線程
    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what){
                case 1:
                    System.out.println("handleMessage thread id " + Thread.currentThread().getId());
                    System.out.println("msg.arg1:" + msg.arg1);
                    System.out.println("msg.arg2:" + msg.arg2);
                    System.out.println("msg.obj:" + msg.obj.toString());
                    System.out.println("msg.setDate:" + msg.getData().get("QQ"));

                    textview.setText("success");
                    break;
            }
        }
    };

   private Handler mHandler2 = new Handler(new Handler.Callback() {
       @Override
       public boolean handleMessage(@NonNull Message msg) {
           switch (msg.what){
               case 1:
                   System.out.println("handleMessage thread id " + Thread.currentThread().getId());
                   System.out.println("msg.arg1:" + msg.arg1);
                   System.out.println("msg.arg2:" + msg.arg2);
                   System.out.println("msg.obj:" + msg.obj.toString());
                   System.out.println("msg.setDate:" + msg.getData().get("QQ"));

                   textview.setText("success");
                   break;
           }
           return false;
       }
   });
複製代碼

也就是說不管哪一種方式，咱們都得經過某種方式實現handleMessage方法，這點與Java中對Thread的設計有殊途同歸之處。

在Java中，若是咱們想使用多線程，有兩種辦法：

（1）向Thread的構造函數傳入一個Runnable對象，並實現Runnable的run方法。

（2）無需向Thread的構造函數傳入Runnable對象，可是要重寫Thread自己的run方法。

2. mLooper = Looper.myLooper();

首先經過Looper.myLooper()獲取了當前線程保存的Looper實例。

3.mQueue = mLooper.mQueue;

而後再獲取該Looper實例中保存的消息隊列MessageQueue，這樣就保證了Handler的實例與Looper實例中MessageQueue關聯上了。

（二）sendMessage()方法

public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
複製代碼
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }
複製代碼
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;
        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);
    }
複製代碼

展轉反則最後調用了sendMessageAtTime，在此方法內部有直接獲取MessageQueue，而後調用了enqueueMessage方法，咱們再來看看此方法：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
複製代碼

上面有幾行代碼是關鍵代碼:

1. msg.target = this;

該代碼將Message的target綁定爲當前的Handler。

2. queue.enqueueMessage;

變量queue表示的是Handler所綁定的消息隊列MessageQueue，經過調用queue.enqueueMessage(msg, uptimeMillis)咱們將Message放入到消息隊列中。

如今已經很清楚了Looper會調用prepare()和loop()方法，在當前執行的線程中保存一個Looper實例，這個實例會保存一個MessageQueue對象，而後當前線程進入一個無限循環中去，不斷從MessageQueue中讀取Handler發來的消息。而後再回調建立該消息的Handler中的dispathMessage方法。Handler的dispatchMessage的源碼以下：

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

上面有幾行代碼是關鍵代碼:

1. if (msg.callback != null) { handleCallback(msg); }

首先會判斷msg.callback存不存在，msg.callback是Runnable類型，若是msg.callback存在，那麼說明該Message是經過執行Handler的postXXX系列方法將Message放入到消息隊列中的，這種狀況下會執行handleCallback(msg), handleCallback源碼以下：

private static void handleCallback(Message message) {
        message.callback.run();
}
複製代碼

這樣咱們咱們就清楚地看到咱們執行了msg.callback的run方法，也就是執行了postXXX所傳遞的Runnable對象的run方法。

2. else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } }

若是咱們不是經過postXXX系列方法將Message放入到消息隊列中的，那麼msg.callback就是null，代碼繼續往下執行，接着咱們會判斷Handler的成員字段mCallback存不存在。mCallback是Hanlder.Callback類型的，咱們在上面的Handler構造函數提到過，在Handler的構造函數中咱們能夠傳遞Hanlder.Callback類型的對象，該對象須要實現handleMessage方法，若是咱們在構造函數中傳遞了該Callback對象，那麼咱們就會讓Callback的handleMessage方法來處理Message。

3.handleMessage(msg);

若是咱們在構造函數中沒有傳入Callback類型的對象，那麼mCallback就爲null,那麼咱們會調用Handler自身的hanldeMessage方法，該方法默認是個空方法，咱們須要本身是重寫實現該方法。

綜上，咱們能夠看到Handler提供了三種途徑處理Message，並且處理有先後優先級之分：首先嚐試讓postXXX中傳遞的Runnable執行，其次嘗試讓Handler構造函數中傳入的Callback的handleMessage方法處理，最後纔是讓Handler自身的handleMessage方法處理Message。

讓咱們看一下handleMessage(msg)

/**
    * Subclasses must implement this to receive messages.
    */
   public void handleMessage(Message msg) {
   }
複製代碼

能夠看到這是一個空方法，爲何呢，由於消息的最終回調是由咱們控制的，咱們在建立handler的時候都是複寫handleMessage方法，而後根據msg.what進行消息處理。

private Handler mHandler = new Handler(){
		public void handleMessage(android.os.Message msg){
			switch (msg.what){
			case value:
			    break;
			default:
			     break;
			}   
		};
	};
複製代碼

到此，sendMessage方式流程已經解釋完畢，接下來看下post方式。

（三）post()方法

mHandler.post(new Runnable()
		{
			@Override
			public void run()
			{
				Log.e("TAG", Thread.currentThread().getName());
				mTxt.setText("yoxi");
			}
		});
複製代碼

而後run方法中能夠寫更新UI的代碼，其實這個Runnable並無建立什麼線程，而是發送了一條消息，下面看源碼：

public final boolean post(Runnable r){
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
複製代碼
private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }
複製代碼

能夠看到，在getPostMessage中，獲得了一個Message對象，而後將咱們建立的Runable對象做爲callback屬性，賦值給了此message。 注：產生一個Message對象，能夠new也可使用Message.obtain()方法；二者均可以，可是更建議使用obtain方法，由於Message內部維護了一個Message池用於Message的複用，避免使用new從新分配內存。

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;
        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.sendMessage同樣，調用了sendMessageAtTime，而後調用了enqueueMessage方法，給msg.target賦值爲handler，最終加入MessagQueue。

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

能夠看到，這裏msg的callback和target都有值，那麼會執行msg.callback != null的判斷，則執行handleCallback回調，也就是咱們的Runnable對象。

3、總結

到此，這個流程已經解釋完畢，讓咱們首先總結一下：

  1. 首先Looper.prepare()在本線程中保存一個Looper實例，而後該實例中保存一個MessageQueue對象；由於Looper.prepare()在一個線程中只能調用一次，因此MessageQueue在一個線程中只會存在一個。

  2. 在Lopper構造函數中，建立了一個消息隊列MessageQueue，並將其賦值給其成員字段mQueue,這樣Looper也就與MessageQueue經過成員字段mQueue進行了關聯。

  3. Looper.loop()會讓當前線程進入一個無限循環，不端從MessageQueue的實例中讀取消息，而後回調msg.target.dispatchMessage(msg)方法。

  4. Handler的構造方法，會首先獲得當前線程中保存的Looper實例，進而與Looper實例中的MessageQueue想關聯。

  5. Handler的sendMessage方法，會給msg的target賦值爲handler自身，而後加入MessageQueue中。

  6. 在構造Handler實例時，咱們會重寫handleMessage方法，也就是msg.target.dispatchMessage(msg)最終調用的方法。

4、一圖勝千言

咱們在本文討論了Thread、MessageQueue、Looper以及Hanlder的之間的關係，咱們能夠經過以下一張傳送帶的圖來更形象的理解他們之間的關係。

在現實生活的生產生活中，存在着各類各樣的傳送帶，傳送帶上面灑滿了各類貨物，傳送帶在發動機滾輪的帶動下一直在向前滾動，不斷有新的貨物放置在傳送帶的一端，貨物在傳送帶的帶動下送到另外一端進行收集處理。

咱們能夠把傳送帶上的貨物看作是一個個的Message，而承載這些貨物的傳送帶就是裝載Message的消息隊列MessageQueue。傳送帶是靠發送機滾輪帶動起來轉動的，咱們能夠把發送機滾輪看作是Looper，而發動機的轉動是須要電源的，咱們能夠把電源看作是線程Thread，全部的消息循環的一切操做都是基於某個線程的。一切準備就緒，咱們只須要按下電源開關發動機就會轉動起來，這個開關就是Looper的loop方法，當咱們按下開關的時候，咱們就至關於執行了Looper的loop方法，此時Looper就會驅動着消息隊列循環起來。

那Hanlder在傳送帶模型中至關於什麼呢？咱們能夠將Handler看作是放入貨物以及取走貨物的管道：貨物從一端順着管道劃入傳送帶，貨物又從另外一端順着管道劃出傳送帶。咱們在傳送帶的一端放入貨物的操做就至關於咱們調用了Handler的sendMessageXXX、sendEmptyMessageXXX或postXXX方法，這就把Message對象放入到了消息隊列MessageQueue中了。當貨物從傳送帶的另外一端順着管道劃出時，咱們就至關於調用了Hanlder的dispatchMessage方法，最終執行handleMessage方法，在該方法中咱們完成對Message的處理。

特別感謝：

Android 異步消息處理機制 讓你深刻理解 Looper、Handler、Message三者關係

深刻源碼解析Android中的Handler,Message,MessageQueue,Looper

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程