Android之handler异步消息处理机制解析

Android UI线程是不安全的，如果尝试在子线程中更新ui，程序就会奔溃，所以我们经常会使用Handler，AsyncTask,HandlerThread,IntentService 来进行处理以便达到在主线程中更新ui的操作，这种机制被称为异步消息处理机制

1:创建Handler对象
我们在子线程以及主线程中各创建一个Handler

Handler handler1;
Handler handler2;
handler1 = new Handler();
        Log.i("handler1", "onCreate: " + Thread.currentThread().getName());// main
new Thread(new Runnable() {
    @Override
    public void run() {
        Log.i("handler2", "onCreate: " + Thread.currentThread().getName());// thread
        handler2 = new Handler();
    }
}).start();

我们发现在子线程中创建handler报运行时错误，说没有调用Looper.prepare()不能在子线程中创建Handler
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:200)
at android.os.Handler.<init>(Handler.java:114)
at com.adnonstop.beautymall.MainActivity$2.run(MainActivity.java:53)
at java.lang.Thread.run(Thread.java:818)

public Handler() {
    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());
        }
    }
    // 获取looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    // 获取MessageQueue
    mQueue = mLooper.mQueue;
    mCallback = null;
}

可以看到，初始化handler时调用了Looper.myLooper()方法获取了一个Looper对象，如果Looper对象为空，则会抛出一个运行时异常，提示的错误正是 Can’t create handler inside thread that has not called Looper.prepare()！那什么时候Looper对象才可能为空呢？这就要看看Looper.myLooper()中的代码了，如下所示：

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

这个方法非常简单，就是从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧，当然是Looper.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());
}

首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。这样也就完全解释了为什么我们要先调用Looper.prepare()方法，才能创建Handler对象。同时也可以看出每个线程中最多只会有一个Looper对象。

子线程中的我们弄明白了，那为什么主线程中的不需要初始化looper呢，这其实时由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。查看ActivityThread中的main()方法，代码如下所示：

  public static void main(String[] args) {
      ...
      //内部其实调用的时Looper.prepare（）
      Looper.prepareMainLooper();
      ActivityThread thread = new ActivityThread();
      thread.attach(false);
      if (sMainThreadHandler == null) {
          sMainThreadHandler = thread.getHandler();
      }
      AsyncTask.init();
      if (false) {
          Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
      }
      Looper.loop();// 从消息队列去消息出来，给handler.handleMessage处理
      throw new RuntimeException("Main thread loop unexpectedly exited");
  }

这样基本就将Handler的创建过程完全搞明白了，总结一下就是在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。
初始化之后我们要创建消息Message，然后再将消息发送出去
Message创建以及源码分析

Handler中提供了很多个发送消息的方法，其中除了sendMessageAtFrontOfQueue()方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中，

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

sendMessageAtTime()方法接收两个参数：

msg参数就是我们发送的Message对象，
uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间

sendMessageAtTime方法里面的两个参数全部交由MessageQueue 来处理，并且判断queue是否为null,如果为null的话则报 没有queue无法发送消息的错误，那这个时什么时候创建的呢，细心的会发现在获取Looper之后会调用mQueue = mLooper.mQueue;来获取的，简单的来说它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。

final boolean enqueueMessage(Message msg, long when) {
    if (msg.when != 0) {
        throw new AndroidRuntimeException(msg + " This message is already in use.");
    }
    if (msg.target == null && !mQuitAllowed) {
        throw new RuntimeException("Main thread not allowed to quit");
    }
    synchronized (this) {
        if (mQuiting) {
            RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
            Log.w("MessageQueue", e.getMessage(), e);
            return false;
        } else if (msg.target == null) {
            mQuiting = true;
        }
        msg.when = when;
        Message p = mMessages;
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;
            mMessages = msg;
            this.notify();
        } else {
            Message prev = null;
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
            msg.next = prev.next;
            prev.next = msg;
            this.notify();
        }
    }
    return true;
}

MessageQueue单链表来进行保存message，入队其实就是将所有的消息按时间uptimeMillis来进行排序。具体的操作方法就根据时间的顺序调用msg.next，从而为每一个消息指定它的下一个消息是什么。

现在入队操作我们就已经看明白了，那出队操作是在哪里进行的呢?这个就需要看一看Looper.loop()方法的源码了

public static final void loop() {
    Looper me = myLooper();
    MessageQueue queue = me.mQueue;
    while (true) {
        Message msg = queue.next(); // might block
        if (msg != null) {
            if (msg.target == null) {
                return;
            }
            if (me.mLogging!= null) me.mLogging.println(
                    ">>>>> Dispatching to " + msg.target + " "
                    + msg.callback + ": " + msg.what
                    );
            msg.target.dispatchMessage(msg);
            if (me.mLogging!= null) me.mLogging.println(
                    "<<<<< Finished to    " + msg.target + " "
                    + msg.callback);
            msg.recycle();
        }
    }
}

可以看到，该方法进入了一个死循环，然后不断地调用的MessageQueue的next()方法取出对列中的消息。它的简单逻辑就是如果当前MessageQueue中存在mMessages(即待处理消息)，就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。
每当有一个消息出队，就将它传递到msg.target的dispatchMessage()方法中，那这里msg.target又是什么呢？其实就是Handler，sendMessageAtTime方法里面给每个消息标注了msg.target = this this指代的就是当前的handler

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
         // callback 其实是一个Runnable
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

如果mCallback不为空，则调用mCallback的handleMessage()方法，否则直接调用Handler的handleMessage()方法，并将消息对象作为参数传递过去。

一个最标准的异步消息处理线程的写法应该是这样

class handlerThread extends Thread {
    private Handler handler;
    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler() {
            @SuppressLint("HandlerLeak")
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
            }
        };
        Looper.loop();
    }
}

除了发送消息之外，我们还有几种方式来在主线程中更新ui

1. Handler的post()方法
2. View的post()方法
3. Activity的runOnUiThread()方法

内部原理其实就是将任务runnable赋值给message中的callback
Message中的变量 Runnable callback;
 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;
 }

本文地址：https://blog.csdn.net/yangsenhao211423/article/details/107443656