首页 技术 正文

使用过AsyncTask、EventBus、Volley以及Retrofit，必须好好了解handler运行机制

技术 2022年11月20日
0 收藏 419 点赞 4,019 浏览 12017 个字

我们都知道在UI线程中不能进行耗时操作，例如数据读写、网络请求。Android 4.0开始，在主线程中进行网络请求甚至会抛出Android.os.NetworkOnMainThreadException。这个时候，我们就会开始依赖Handler。我们在子线程进行耗时操作后，将请求结果通过Handler的sendMessge**() 方法发送出去，在主线程中通过Handler的handleMessage 方法处理请求结果，进行UI的更新。

后来随着AsyncTask、EventBus、Volley以及Retrofit 的出现，Handler的作用似乎被弱化，逐渐被大家遗忘。其实不然，AsyncTask其实是基于Handler进行了非常巧妙的封装，Handler的使用依然是其核心。Volley同样也是使用到了Handler。因此，我们有必要了解一下Handler的实现机制。

神奇的Handler

记得很久之前的一天，我在阅读别人的代码时，看到了这样一段：

  1.  new Handler().postDelayed(new Runnable() {
  2.  @Override
  3.  public void run() {
  4.  Toast.makeText(mContext, “I’m new Handler !”, Toast.LENGTH_SHORT).show();
  5.  }
  6.  }, 1000);

第一印象就是，这不是在子线程中进行UI操作吗？这代码有问题吧，于是乎立刻在自己电脑上写了个demo试了一下，结果发现真的没有问题。在一阵懵逼过后，我又写出下面的代码，测试一下子线程中到底能不能进行UI操作。

  1.  new Thread(new Runnable() {
  2.  @Override
  3.  public void run() {
  4.   
  5.  try {
  6.  Thread.sleep(2000);
  7.  } catch (InterruptedException e) {
  8.  e.printStackTrace();
  9.  }
  10.   
  11.  Toast.makeText(mContext, “I’m new Thread !”, Toast.LENGTH_SHORT).show();
  12.   
  13.  }
  14.  }).start();

结果很明显，程序一启动立刻就奔溃了。并抛出异常java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()。
于是乎我又在try block 之前添加了Looper.prepare()这行代码。再次运行程序虽然没有奔溃，但也没有任何反应，Toast也没显示。

那么Handler到底是什么呢？他怎么就这么神奇。

实现机制解析

首先，我们从整体上了解一下，在整个Handler机制中所有使用到的类，主要包括Message，MessageQueue,Looper以及Handler。

使用过AsyncTask、EventBus、Volley以及Retrofit，必须好好了解handler运行机制

好了，为了方便后面的叙述，我们就首先了解一下这个类图中使用到几个类，及其关键方法。

Message

首先看一下Message这个类的定义（截取部分）

  1.   public final class Message implements Parcelable {
  2.   
  3.   public int what;
  4.   public int arg1;
  5.   public int arg2;
  6.   public Object obj;
  7.   /*package*/ Handler target;
  8.   /*package*/ Runnable callback;
  9.   
  10.   /**
  11.   * Return a new Message instance from the global pool. Allows us to
  12.   * avoid allocating new objects in many cases.
  13.   */
  14.   public static Message obtain() {
  15.   synchronized (sPoolSync) {
  16.   if (sPool != null) {
  17.   Message m = sPool;
  18.   sPool = m.next;
  19.   m.next = null;
  20.   m.flags = 0; // clear in-use flag
  21.   sPoolSize–;
  22.   return m;
  23.   }
  24.   }
  25.   return new Message();
  26.   }
  27.   
  28.   /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
  29.   */
  30.   public Message() {
  31.   }
  32.  }

看到这个类的前四个属性，大家应该很熟悉，就是我们使用Handler时经常用到的那几个属性。用来在传递我们特定的信息。其次我们还可以总结出以下信息：

  • Message 实现了Parcelable 接口，也就是说实现了序列化，这就说明Message可以在不同进程之间传递。
  • 包含一个名为target的Handler 对象
  • 包含一个名为callback的Runnable 对象
  • 使用obtain 方法可以从消息池中获取Message的实例，也是推荐大家使用的方法，而不是直接调用构造方法。

MessageQueue

MessageQueue顾名思义，就是上面所说的Message所组成的queue。

首先看一下构造方法：

  1.  MessageQueue(boolean quitAllowed) {
  2.   mQuitAllowed = quitAllowed;
  3.   mPtr = nativeInit();
  4.   }

接收一个参数，决定当前队列是否允许被终止。同时调用 一个native方法，初始化了一个long类型的变量mPtr。

同时，在这个类当中，还定义了一个next 方法，用于返回一个Message 。

  1.  Message next() {
  2.   // Return here if the message loop has already quit and been disposed.
  3.   // This can happen if the application tries to restart a looper after quit
  4.   // which is not supported.
  5.   final long ptr = mPtr;
  6.   if (ptr == 0) {
  7.   return null;
  8.   }
  9.   ……
  10.   }

由于这个方法中有一些native调用，未能完全理解，只知道会返回一个Message对象。

这个next方法相当于是队列出栈，有出栈必然有进栈，enqueueMessage 方法就是完成这个操作；这个我们后面再说。

Looper

上面说到了MessageQueue，那么这个Queue又是由谁创建的呢？其实就是Looper。关于Looper有两个关键方法：

prepare() 和 loop()

Looper-prepare()

  1.   public static void prepare() {
  2.   prepare(true);
  3.   }
  4.   
  5.   private static void prepare(boolean quitAllowed) {
  6.   if (sThreadLocal.get() != null) {
  7.   throw new RuntimeException(“Only one Looper may be created per thread”);
  8.   }
  9.   sThreadLocal.set(new Looper(quitAllowed));
  10.   }

可以看到，对于每一个线程只能有一个Looper。也就是说执行prepare方法时，必然执行最后一行代码
sThreadLocal.set(new Looper(quitAllowed));

我们再看Looper(quitAllowed)方法：

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

这样，MessageQueue 就被创建了。这里也可以看到，默认情况下，一个MessageQueue的quiteAllow=true。

这里使用到的sThreadLocal 是一个ThreadLocal对象。简单来说，使用它可以用来解决多线程程序的并发问题。使用set方法，将此线程局部变量的当前线程副本中的值设置为指定值；使用get方法，返回此线程局部变量的当前线程副本中的值。

Looper-loop()

再看一下loop方法（截取主要逻辑）

  1.  public static void loop() {
  2.   final Looper me = myLooper();
  3.   if (me == null) {
  4.   throw new RuntimeException(“No Looper; Looper.prepare() wasn’t called on this thread.”);
  5.   }
  6.   final MessageQueue queue = me.mQueue;
  7.   for (;;) {
  8.   Message msg = queue.next(); // might block
  9.   if (msg == null) {
  10.   // No message indicates that the message queue is quitting.
  11.   return;
  12.   }
  13.   msg.target.dispatchMessage(msg);
  14.   msg.recycleUnchecked();
  15.   }
  16.   }

首先看第一句代码执行的方法：

  1.   /**
  2.   * Return the Looper object associated with the current thread. Returns
  3.   * null if the calling thread is not associated with a Looper.
  4.   */
  5.   public static @Nullable Looper myLooper() {
  6.   return sThreadLocal.get();
  7.   }

很明显，这样返回的Looper就是刚才prepare时set进去的那个，因为都是在同一线程。再明确一下，一个线程对应一个Looper。

这样就确保我们可以在不同的线程中创建各自的Handler，进行各自的通信而不会互相干扰

回到代码，后面逻辑就很简单了，在一个死循环中，通过队列出栈的形式，不断从MessageQueue 中取出新的Message，然后执行msg.target.dispatchMessage(msg) 方法，还记的前面Message类的定义吗，这个target属性其实就是一个Handler 对象，因此在这里就会不断去执行Handler 的dispatchMessage 方法。如果取出的Message对象为null，就会跳出死循环，一次Handler的工作整个就结束了。

Handler

上面说了这么多终于轮到Handler，那么就看看在Handler中到底发生了什么。回到我们一开始的代码。

  1.   new Handler().postDelayed(new Runnable() {
  2.   @Override
  3.   public void run() {
  4.   String currentName=Thread.currentThread().getName();
  5.   Toast.makeText(mContext, “I’m new Thread “+currentName, Toast.LENGTH_SHORT).show();
  6.   }
  7.   }, 4000);

这里我们用Toast弹出了当前线程的name，结果发现这个线程的名字居然是main，这也是必然结果

让我们一步一步看看，神奇的Handler到底是怎样工作的。就从这个代码开始解读。首先看一下Handler的构造方法。

  1.   public Handler() {
  2.   this(null, false);
  3.   }
  4.   
  5.   —————
  6.   
  7.   public Handler(Callback callback, boolean async) {
  8.   if (FIND_POTENTIAL_LEAKS) {
  9.   final Class<? extends Handler> klass = getClass();
  10.   if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
  11.   (klass.getModifiers() & Modifier.STATIC) == 0) {
  12.   Log.w(TAG, “The following Handler class should be static or leaks might occur: ” +
  13.   klass.getCanonicalName());
  14.   }
  15.   }
  16.   
  17.   mLooper = Looper.myLooper();
  18.   if (mLooper == null) {
  19.   throw new RuntimeException(
  20.   “Can’t create handler inside thread that has not called Looper.prepare()”);
  21.   }
  22.   mQueue = mLooper.mQueue;
  23.   mCallback = callback;
  24.   mAsynchronous = async;
  25.   }

这里做的事情很简单，就是完成了一些初始化的工作，调用Looper.myLooper()赋值给当前mLooper，关联MessageQueue；这里由于代码中调用的是不带任何参数的构造函数，因此会创建一个mCallback=null且非异步执行的Handler 。

接下看postDelayed 方法。

  1.  public final boolean postDelayed(Runnable r, long delayMillis)
  2.   {
  3.   return sendMessageDelayed(getPostMessage(r), delayMillis);
  4.   }
  5.   
  6.  private static Message getPostMessage(Runnable r) {
  7.   Message m = Message.obtain();
  8.   m.callback = r;
  9.   return m;
  10.   }

这里通过getPostMessage(Runnable r) 方法，把我们在Activity里写的Runnable 这个线程赋给了Message 的callback这个属性。

平时大家使用Handler也发现了，他为我们提供了很多方法

使用过AsyncTask、EventBus、Volley以及Retrofit，必须好好了解handler运行机制

因此，上面的postDelayed经过了各种辗转反侧，最终来到了这里：

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

经过之前的构造方法，mQueue显然不为null，继续往下看

  1.   private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
  2.   msg.target = this;
  3.   if (mAsynchronous) {
  4.   msg.setAsynchronous(true);
  5.   }
  6.   return queue.enqueueMessage(msg, uptimeMillis);
  7.   }

注意，注意，注意 这里进行了一次赋值：

msg.target = this;

前面提到，这个target就是一个Handler对象，因此这里Message就和当前Handler关联起来了。enqueueMessage，哈哈，这就是我们之前在MessageQueue中提到的进栈操作的方法，我们看一下：

  1.  boolean enqueueMessage(Message msg, long when) {
  2.  if (msg.target == null) {
  3.  throw new IllegalArgumentException(“Message must have a target.”);
  4.  }
  5.  if (msg.isInUse()) {
  6.  throw new IllegalStateException(msg + ” This message is already in use.”);
  7.  }
  8.   
  9.  synchronized (this) {
  10.  if (mQuitting) {
  11.  IllegalStateException e = new IllegalStateException(
  12.  msg.target + ” sending message to a Handler on a dead thread”);
  13.  Log.w(TAG, e.getMessage(), e);
  14.  msg.recycle();
  15.  return false;
  16.  }
  17.   
  18.  msg.markInUse();
  19.  msg.when = when;
  20.  Message p = mMessages;
  21.  boolean needWake;
  22.  if (p == null || when == 0 || when < p.when) {
  23.  // New head, wake up the event queue if blocked.
  24.  msg.next = p;
  25.  mMessages = msg;
  26.  needWake = mBlocked;
  27.  } else {
  28.  // Inserted within the middle of the queue. Usually we don’t have to wake
  29.  // up the event queue unless there is a barrier at the head of the queue
  30.  // and the message is the earliest asynchronous message in the queue.
  31.  needWake = mBlocked && p.target == null && msg.isAsynchronous();
  32.  Message prev;
  33.  for (;;) {
  34.  prev = p;
  35.  p = p.next;
  36.  if (p == null || when < p.when) {
  37.  break;
  38.  }
  39.  if (needWake && p.isAsynchronous()) {
  40.  needWake = false;
  41.  }
  42.  }
  43.  msg.next = p; // invariant: p == prev.next
  44.  prev.next = msg;
  45.  }
  46.   
  47.  // We can assume mPtr != 0 because mQuitting is false.
  48.  if (needWake) {
  49.  nativeWake(mPtr);
  50.  }
  51.  }
  52.  return true;
  53.  }

这个方法就是典型的队列入队操作，只不过会根据Message这个对象特有的一些属性，以及当前的状态是否inUse，是否已经被quit等进行一些额外的判断。

这样，我们就完成消息入队的操作。还记得我们在Looper中说过，在loop方法中，会从MessageQueue中取出Message 并执行他的dispatchMessage 方法。

dispatchMessage

  1.  public void dispatchMessage(Message msg) {
  2.  if (msg.callback != null) {
  3.  handleCallback(msg);
  4.  } else {
  5.  if (mCallback != null) {
  6.  if (mCallback.handleMessage(msg)) {
  7.  return;
  8.  }
  9.  }
  10.  handleMessage(msg);
  11.  }
  12.  }

到这里，就很明确了，在之前的postDelayed 方法中，已经通过getPostMessage，实现了 m.callback = r；这样这里就会执行第一个if语句：

  1.  private static void handleCallback(Message message) {
  2.  message.callback.run();
  3.  }

这样，就会执行我们在Activity 的Runnable 中的run 方法了，也就是显示Toast。

到了这里，我们终于明白了，使用Handler 的postDelay 方法时，其Runnable中的run方法并不是在子线程中执行，而是把这个Runnable赋值给了一个Message对象的callback属性，而这个Message会被传递到创建Handler所在的线程，也就是这里的主线程，所以这个Toast的显示依旧是在主线程中。这也和postDelay API 中所声明的内容是一致的。

/**

  1.  * Causes the Runnable r to be added to the message queue, to be run
  2.  * after the specified amount of time elapses.
  3.  * The runnable will be run on the thread to which this handler
  4.  * is attached.
  5.  */

到这里，一开始所说的第一个代码块所执行的逻辑已经理清楚了，但是还是有一点疑问，我们并没有在Handler的构造方法中看到Looper 的prepare()方法和loop() 方法被执行，那么他们到底是在哪里执行的呢？这个问题我也是疑惑了很久，最终才明白是在
ActivityThread的main方法中执行。简单来说，ActivityThread是Java层面一个Android程序真正的入口。关于ActivityThread更多的内容可以看看这篇文章。

ActivityThread-main方法（截取主要部分）

  1.  public static void main(String[] args) {
  2.   
  3.   
  4.   Looper.prepareMainLooper();
  5.   
  6.   ActivityThread thread = new ActivityThread();
  7.   thread.attach(false);
  8.   
  9.   if (sMainThreadHandler == null) {
  10.   sMainThreadHandler = thread.getHandler();
  11.   }
  12.   
  13.   if (false) {
  14.   Looper.myLooper().setMessageLogging(new
  15.   LogPrinter(Log.DEBUG, “ActivityThread”));
  16.   }
  17.   
  18.   // End of event ActivityThreadMain.
  19.   Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  20.   Looper.loop();
  21.   
  22.   throw new RuntimeException(“Main thread loop unexpectedly exited”);
  23.   }

这个类藏的比较深，你可以在Android-SDK\sources\android-24\android\app 这个目录中找到。

也就是说，在一个Android 程序启动之初，系统会帮我们为这个主线程创建好Looper。只不过这个方法名字比较特殊，叫做prepareMainLooper。

  1.  public static void prepareMainLooper() {
  2.   prepare(false);
  3.   synchronized (Looper.class) {
  4.   if (sMainLooper != null) {
  5.   throw new IllegalStateException(“The main Looper has already been prepared.”);
  6.   }
  7.   sMainLooper = myLooper();
  8.   }
  9.   }

注意这里调用prepare时传递的参数值为false，和我们之前创建普通Looper时是不同的，这也 可以理解，因为这是主线程，怎么可以被允许被外部代码终止呢。

到这里，我们终于完整的理解了开头我们提到的第一个代码块的内容了。

至于第二种使用写法出错的原因也在明显不过了，主线程会在程序启动时在main方法中帮我们主动创建Looper，调用loop方法；而我们自己创建的线程就得我们主动去调用Looper.prepare()，这样才能保证MessageQueue被创建，程序不会奔溃；但是我们所期望的Toast依然没有显示出来，这是为什么呢？因为，我们没有调用loop方法。消息被加入队列了，但是没有办法弹出。因此我们将代码修改如下：

  1.   new Thread(new Runnable() {
  2.   @Override
  3.   public void run() {
  4.   
  5.   Looper.prepare();
  6.   
  7.   try {
  8.   Thread.sleep(2000);
  9.   } catch (InterruptedException e) {
  10.   e.printStackTrace();
  11.   }
  12.   
  13.   Toast.makeText(mContext, “I’m new Thread !”, Toast.LENGTH_SHORT).show();
  14.   
  15.   Looper.loop();
  16.   
  17.   }
  18.   }).start();

这样就没问题了，Toast就可以显示出来了。实际上，平时写代码肯定不会这么写，这里只是为了说明问题。

handleMessage

回想一下，我们使用Handler最常见的场景：

  1.  handler = new MyHandler();
  2.   
  3.  private class MyCallback implements Callback {
  4.   
  5.   @Override
  6.   public void onFailure(Call call, IOException e) {
  7.   Message msg = new Message();
  8.   msg.what = 100;
  9.   msg.obj = e;
  10.   handler.sendMessage(msg);
  11.   }
  12.   
  13.   @Override
  14.   public void onResponse(Call call, Response response) throws IOException {
  15.   Message msg = new Message();
  16.   msg.what = 200;
  17.   msg.obj = response.body().string();
  18.   handler.sendMessage(msg);
  19.   }
  20.   }

上面的代码是OKHttp的回调方法，由于其回调方法不处于UI 线程，因此需要我们通过Handler将结果发送到主线中取执行。
那么这又是怎样实现的呢？

前面我们截图说过，Handler为我们提供许多sendMessage 相关的方法，因此这里我们在onResponse 中执行的sendMessage 经过层层传递，殊途同归依然会回到MessageQueue的enqueueMessage方法，也就是说所有的sendMessageXXX方法完成的工作无非就是队列入栈的工作，就是将包含特定信息的Message加入到MessageQueue中。而我们也知道，通过loop方法，会从MessageQueue中取出Message，执行每一个Message 所对应Handler的dispatchMessage方法，我们再看一次这个方法：

  1.   
  2.   
  3.  public void dispatchMessage(Message msg) {
  4.   if (msg.callback != null) {
  5.   handleCallback(msg);
  6.   } else {
  7.   if (mCallback != null) {
  8.   if (mCallback.handleMessage(msg)) {
  9.   return;
  10.   }
  11.   }
  12.   handleMessage(msg);
  13.   }
  14.   }

这一次，我们创建的Message很简单，其callback属性必然是空的，而且在实例化Handler时，调用的是其无参构造函数 ，因此这个时候，就会执行最后一行代码handleMessage(msg) ；

  1.  /**
  2.   * Subclasses must implement this to receive messages.
  3.   */
  4.   public void handleMessage(Message msg) {
  5.   }

空的 ! 没错，这个方法就是空的，因为这是需要我们在Handler的继承类中自己实现的方法呀。比如下面这样；

  1.  class MyHandler extends Handler {
  2.   @Override
  3.   public void handleMessage(Message msg) {
  4.   super.handleMessage(msg);
  5.   loading.setVisibility(View.GONE);
  6.   switch (msg.what) {
  7.   case 100:
  8.   Object e = msg.obj;
  9.   Toast.makeText(mContext, e.toString(), Toast.LENGTH_SHORT).show();
  10.   break;
  11.   case 200:
  12.   String response = (String) msg.obj;
  13.   tv.setText(response);
  14.   break;
  15.   default:
  16.   break;
  17.   }
  18.   }
  19.   }

我们在handleMessage方法中，实现了自己的处理逻辑。

总结

好了，这就是Handler的实现机制，这里再做一次总结称述。

  • 通过Looper的prepare方法创建MessageQueue
  • 通过loop方法找到和当前线程匹配的Looper对象me
  • 从me中取出消息队列对象mQueue
  • 在一个死循环中，从mQueue中取出Message对象
  • 调用每个Message对象的msg.target.dispatchMesssge方法
  • 也就是Handler的dispatchMessage 方法
  • 在dispatchMessage 根据Message对象的特点执行特定的方法。

至此，终于弄明白了Handler的运行机制。

点赞 419

贡献者

上一篇： 简单的TabLayout+Fragment选项卡
下一篇： c#事务处理（sqlTransaction）
相关推荐
python开发_常用的python模块及安装方法
python开发_常用的python模块及安装方法
adodb：我们领导推荐的数据库连接组件bsddb3：BerkeleyDB的连接组件Cheetah-1.0：我比较喜欢这个版本的cheeta…
技术
日期：2022-11-24 点赞：878 阅读：8,999
Educational Codeforces Round 11 C. Hard Process 二分
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接：http://www.codeforces.com/contest/660/problem/CDes…
技术
日期：2022-11-24 点赞：807 阅读：5,511
下载Ubuntn 17.04 内核源代码
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
技术
日期：2022-11-24 点赞：569 阅读：6,357
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
技术
日期：2022-11-24 点赞：733 阅读：6,140
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式，并且由于涉及到要把拍到的照片显…
技术
日期：2022-11-24 点赞：512 阅读：7,770
Struts的使用
Struts的使用
一、Struts2的获取　　Struts的官方网站为：http://struts.apache.org/　　下载完Struts2的jar包,…
技术
日期：2022-11-24 点赞：671 阅读：4,848
Lomu

贡献者

这家伙很懒，只想把你留下。

文章
87
收藏
0
人气
274,719
粉丝
进主页
文章展示
  • [ 技术 ] python开发_常用的python模块及安装方法
  • [ 技术 ] Educational Codeforces Round 11 C. Hard Process 二分
  • [ 技术 ] 下载Ubuntn 17.04 内核源代码
  • [ 技术 ] 可用Active Desktop Calendar V7.86 注册码序列号
  • [ 技术 ] Android调用系统相机、自定义相机、处理大图片
  • [ 技术 ] Struts的使用
    • 个人收藏笔记记录
    我的笔记
    首页 首页 菜单 首页 首页