1、Handler的构造方法

  • Handler 持有 Looper 的实例，直接持有looper的消息队列
  • Looper.myLooper()获取了当前线程保存的Looper实例
  • mLooper.mQueue取出Looper实例中保存的MessageQueue（消息队列）

  • 这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了

    1. public class Handler {
    3.   final Looper mLooper;
    4.   final MessageQueue mQueue;
    5.   final android.os.Handler.Callback mCallback;
    6.   final boolean mAsynchronous;
    8.   public Handler(@Nullable android.os.Handler.Callback callback, boolean async) {
    10.       mLooper = android.os.Looper.myLooper();
    11.       if (mLooper == null) {
    12.           throw new RuntimeException(
    13.                   "Can't create handler inside thread " + Thread.currentThread()
    14.                           + " that has not called Looper.prepare()");
    15.       }
    16.       mQueue = mLooper.mQueue;
    17.       mCallback = callback;
    18.       mAsynchronous = async;
    19.   }
    21.   @UnsupportedAppUsage
    22.   public Handler(@NonNull Looper looper, @Nullable android.os.Handler.Callback callback, boolean async) {
    23.       mLooper = looper;
    24.       mQueue = looper.mQueue;
    25.       mCallback = callback;
    26.       mAsynchronous = async;
    27.   }
    28. }

    2、Handler的发送消息

    2-1、send系列方法

  • 常用的几个发送消息的方法 ``` public final boolean sendMessage(@NonNull Message msg) {

    1.   return sendMessageDelayed(msg, 0);

    }

    public final boolean sendEmptyMessage(int what) {

    1.   return sendEmptyMessageDelayed(what, 0);

    }

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {

    1.   Message msg = Message.obtain();
    2.   msg.what = what;
    3.   return sendMessageDelayed(msg, delayMillis);

    }

    public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {

    1.   if (delayMillis < 0) {
    2.       delayMillis = 0;
    3.   }
    4.   return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

    }

    public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {

    1.   MessageQueue queue = mQueue;
    2.   if (queue == null) {
    3.       RuntimeException e = new RuntimeException(
    4.               this + " sendMessageAtTime() called with no mQueue");
    5.       Log.w("Looper", e.getMessage(), e);
    6.       return false;
    7.   }
    8.   return enqueueMessage(queue, msg, uptimeMillis);

    }

  1. private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
  2.                                long uptimeMillis) {
  3.     // msg的target就是Handler自己
  4.     msg.target = this;
  5.     msg.workSourceUid = ThreadLocalWorkSource.getUid();
  7.     if (mAsynchronous) {
  8.         msg.setAsynchronous(true);
  9.     }
  10.     return queue.enqueueMessage(msg, uptimeMillis);
  11. }
  1. <a name="EMQVF"></a>
  2. ### 2-2、post系列方法
  4. - 把Runable复制给Message.callBack回调
  1. public final boolean post(@NonNull Runnable r) {
  2.     return  sendMessageDelayed(getPostMessage(r), 0);
  3. }
  5. public final boolean postDelayed(@NonNull Runnable r, long delayMillis) {
  6.     return sendMessageDelayed(getPostMessage(r), delayMillis);
  7. }
  9. private static Message getPostMessage(Runnable r) {
  10.     Message m = Message.obtain();
  11.     m.callback = r;
  12.     return m;
  13. }
  1. <a name="jrR1v"></a>
  2. ### 2-3、hasMessage系列方法
  1. public final boolean hasCallbacks(@NonNull Runnable r) {
  2.     return mQueue.hasMessages(this, r, null);
  3. }
  5. public final boolean hasMessages(int what) {
  6.     return mQueue.hasMessages(this, what, null);
  7. }
  9. public final boolean hasMessages(int what, @Nullable Object object) {
  10.     return mQueue.hasMessages(this, what, object);
  11. }
  1. <a name="Q3nS2"></a>
  2. ### 2-4、remove系列方法
  1. /**
  2.  * 移除消息
  3.  */
  4. public final void removeCallbacks(@NonNull Runnable r) {
  5.     mQueue.removeMessages(this, r, null);
  6. }
  9. public final void removeCallbacks(@NonNull Runnable r, @Nullable Object token) {
  10.     mQueue.removeMessages(this, r, token);
  11. }
  13. public final void removeMessages(int what) {
  14.     mQueue.removeMessages(this, what, null);
  15. }
  17. public final void removeMessages(int what, @Nullable Object object) {
  18.     mQueue.removeMessages(this, what, object);
  19. }
  21. public final void removeCallbacksAndMessages(@Nullable Object token) {
  22.     mQueue.removeCallbacksAndMessages(this, token);
  23. }
  1. <a name="dYemB"></a>
  2. ### 2-5、总体流程
  4. - 各种发送Message的方法最后调用了sendMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法
  5. - enqueueMessage中msg.target赋值为this，即是当前Handler，然后会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去
  6. - 如果大家还记得Looper的loop方法会取出每个msg然后交给msg.target.dispatchMessage(msg)去处理消息，也就是把当前的handler作为msg的target属性
  7. <a name="cXxqg"></a>
  8. ## 3、Handler处理消息
  9. <a name="bziDD"></a>
  10. ### 3-1、消息处理的优先级
  12. - 现在已经很清楚了Looper会调用prepare()和loop()方法，在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，处理消息有三个，优先级如下
  13.    - 优先级1：Message.callback 处理消息，如果不为空，后续的优先级2 3都不会执行
  14.    - 优先级2：Handler.mCallbck 处理消息
  15.       - 方法返回true，后续的优先级3就不会执行
  16.       - 方法返回false，后续的优先级3还会执行
  17.    - 优先级3：复写Handler自己实现的消息处理
  1. /**
  2.  * 处理消息
  3.  * @param msg
  4.  */
  5. public void dispatchMessage(@NonNull Message msg) {
  6.     if (msg.callback != null) {
  7.         handleCallback(msg);
  8.     } else {
  9.         if (mCallback != null) {
  10.             if (mCallback.handleMessage(msg)) {
  11.                 return;
  12.             }
  13.         }
  14.         handleMessage(msg);
  15.     }
  16. }
  18. /**
  19.  * Handler的成员方法 空方法，我们可以在创建Handler的时候复写该方法
  20.  * @param msg
  21.  */
  22. public void handleMessage(@NonNull Message msg) {
  24. }
  1. <a name="USCrm"></a>
  2. ### 3-2、消息处理优先级的代码例子
  4. - 优先级1：Message.callback 处理消息，如果不为空，后续的优先级2 3都不会执行
  1.     new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  5.             Looper.prepare();
  7.             Handler handler = new Handler(Looper.myLooper(),
  8.                     new Handler.Callback() {
  9.                 @Override
  10.                 public boolean handleMessage(@NonNull Message msg) {
  11.                     Log.d(TAG, "Handler.Callback: "+msg.what);
  12.                     return false;
  13.                 }
  14.             }){
  15.                 @Override
  16.                 public void handleMessage(@NonNull Message msg) {
  17.                     super.handleMessage(msg);
  18.                     Log.d(TAG, "Handler.handleMessage: "+msg.what);
  19.                 }
  20.             };
  22.             Message msg = Message.obtain(handler, new Runnable() {
  23.                 @Override
  24.                 public void run() {
  25.                     Log.d(TAG, "Message.callback: ");
  27.                 }
  28.             });
  29.             msg.what = 10;
  31.             handler.sendMessage(msg);
  33.             Looper.loop();
  34.         }
  35.     }).start();

log日志如下： D/MainActivity: Message.callback: 

  2. - 优先级2：Handler.mCallbck 处理消息
  3.    - 方法返回true，后续的优先级3就不会执行
  4.    - 方法返回false，后续的优先级3还会执行
  1.     new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  5.             Looper.prepare();
  7.             Handler handler = new Handler(Looper.myLooper(),
  8.                     new Handler.Callback() {
  9.                 @Override
  10.                 public boolean handleMessage(@NonNull Message msg) {
  11.                     Log.d(TAG, "Handler.Callback: "+msg.what);
  12.                     return true;
  13.                 }
  14.             }){
  15.                 @Override
  16.                 public void handleMessage(@NonNull Message msg) {
  17.                     super.handleMessage(msg);
  18.                     Log.d(TAG, "Handler.handleMessage: "+msg.what);
  19.                 }
  20.             };
  22.             Message msg = Message.obtain(handler);
  23.             msg.what = 10;
  25.             handler.sendMessage(msg);
  27.             Looper.loop();
  28.         }
  29.     }).start();

情况1：Handler.Callback.handleMessage返回true，日志如下 D/MainActivity: Handler.Callback: 10

情况2：Handler.Callback.handleMessage返回，日志如下 D/MainActivity: Handler.Callback: 10 D/MainActivity: Handler.handleMessage: 10

  2. - 优先级3：复写Handler自己实现的消息处理
  1.     new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  5.             Looper.prepare();
  7.             Handler handler = new Handler(Looper.myLooper()){
  8.                 @Override
  9.                 public void handleMessage(@NonNull Message msg) {
  10.                     super.handleMessage(msg);
  11.                     Log.d(TAG, "Handler.handleMessage: "+msg.what);
  12.                 }
  13.             };
  15.             Message msg = Message.obtain(handler);
  16.             msg.what = 10;
  18.             handler.sendMessage(msg);
  20.             Looper.loop();
  21.         }
  22.     }).start();

log日志如下： D/MainActivity: Handler.handleMessage: 10

  1. <a name="o2j8R"></a>
  2. ## 4、Looper/Handler整体流程
  4. - 首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。
  5. - Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。
  6. - Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。
  7. - Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。
  9. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/503653/1616403374774-3f1a6bba-5e21-431e-b157-3116deafc0f4.png#crop=0&crop=0&crop=1&crop=1&height=679&id=Vsybz&margin=%5Bobject%20Object%5D&name=image.png&originHeight=679&originWidth=1135&originalType=binary&ratio=1&rotation=0&showTitle=false&size=458397&status=done&style=none&title=&width=1135)
  11. - 简化代码

public class Handler {

  1. final Looper mLooper;
  2. final MessageQueue mQueue;
  4. /**
  5.  * Handler的Callback可以处理消息
  6.  */
  7. final android.os.Handler.Callback mCallback;
  8. final boolean mAsynchronous;
  10. public Handler(@Nullable android.os.Handler.Callback callback, boolean async) {
  12.     mLooper = android.os.Looper.myLooper();
  13.     if (mLooper == null) {
  14.         throw new RuntimeException(
  15.                 "Can't create handler inside thread " + Thread.currentThread()
  16.                         + " that has not called Looper.prepare()");
  17.     }
  18.     mQueue = mLooper.mQueue;
  19.     mCallback = callback;
  20.     mAsynchronous = async;
  21. }
  23. @UnsupportedAppUsage
  24. public Handler(@NonNull Looper looper, @Nullable android.os.Handler.Callback callback, boolean async) {
  25.     mLooper = looper;
  26.     mQueue = looper.mQueue;
  27.     mCallback = callback;
  28.     mAsynchronous = async;
  29. }
  31. public final boolean sendMessage(@NonNull Message msg) {
  32.     return sendMessageDelayed(msg, 0);
  33. }
  35. public final boolean sendEmptyMessage(int what) {
  36.     return sendEmptyMessageDelayed(what, 0);
  37. }
  39. public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
  40.     Message msg = Message.obtain();
  41.     msg.what = what;
  42.     return sendMessageDelayed(msg, delayMillis);
  43. }
  45. public final boolean post(@NonNull Runnable r) {
  46.     return  sendMessageDelayed(getPostMessage(r), 0);
  47. }
  49. public final boolean postDelayed(@NonNull Runnable r, long delayMillis) {
  50.     return sendMessageDelayed(getPostMessage(r), delayMillis);
  51. }
  53. private static Message getPostMessage(Runnable r) {
  54.     Message m = Message.obtain();
  55.     m.callback = r;
  56.     return m;
  57. }
  59. public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
  60.     if (delayMillis < 0) {
  61.         delayMillis = 0;
  62.     }
  63.     return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
  64. }
  66. public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
  67.     MessageQueue queue = mQueue;
  68.     if (queue == null) {
  69.         RuntimeException e = new RuntimeException(
  70.                 this + " sendMessageAtTime() called with no mQueue");
  71.         Log.w("Looper", e.getMessage(), e);
  72.         return false;
  73.     }
  74.     return enqueueMessage(queue, msg, uptimeMillis);
  75. }
  77. /**
  78.  * 消息加入消息队列
  79.  * @param queue
  80.  * @param msg
  81.  * @param uptimeMillis
  82.  * @return
  83.  */
  84. private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
  85.                                long uptimeMillis) {
  86.     // msg的target就是Handler自己
  87.     msg.target = this;
  88.     msg.workSourceUid = ThreadLocalWorkSource.getUid();
  90.     if (mAsynchronous) {
  91.         msg.setAsynchronous(true);
  92.     }
  93.     return queue.enqueueMessage(msg, uptimeMillis);
  94. }
  96. /**
  97.  * 判断消息队列中是否有该消息
  98.  */
  99. public final boolean hasCallbacks(@NonNull Runnable r) {
  100.     return mQueue.hasMessages(this, r, null);
  101. }
  103. public final boolean hasMessages(int what) {
  104.     return mQueue.hasMessages(this, what, null);
  105. }
  107. public final boolean hasMessages(int what, @Nullable Object object) {
  108.     return mQueue.hasMessages(this, what, object);
  109. }
  111. /**
  112.  * 移除消息
  113.  */
  114. public final void removeCallbacks(@NonNull Runnable r) {
  115.     mQueue.removeMessages(this, r, null);
  116. }
  119. public final void removeCallbacks(@NonNull Runnable r, @Nullable Object token) {
  120.     mQueue.removeMessages(this, r, token);
  121. }
  123. public final void removeMessages(int what) {
  124.     mQueue.removeMessages(this, what, null);
  125. }
  127. public final void removeMessages(int what, @Nullable Object object) {
  128.     mQueue.removeMessages(this, what, object);
  129. }
  131. public final void removeCallbacksAndMessages(@Nullable Object token) {
  132.     mQueue.removeCallbacksAndMessages(this, token);
  133. }
  136. /**
  137.  * 处理消息
  138.  * @param msg
  139.  */
  140. public void dispatchMessage(@NonNull Message msg) {
  141.     if (msg.callback != null) {
  142.         handleCallback(msg);
  143.     } else {
  144.         if (mCallback != null) {
  145.             if (mCallback.handleMessage(msg)) {
  146.                 return;
  147.             }
  148.         }
  149.         handleMessage(msg);
  150.     }
  151. }
  153. /**
  154.  * Handler的成员方法 空方法，我们可以在创建Handler的时候复写该方法
  155.  * @param msg
  156.  */
  157. public void handleMessage(@NonNull Message msg) {
  159. }

} ```