Android中异步消息处理机制

技术分享
技术分享

1. Thread Local Storage (线程局部存储)

     我们通过位于android.os包下的Looper.class源码可以看到成员变量区有一个线程局部变量sThreadLocal,该类的作用是线程局部存储?那么是线程局部存储TLS?这个问题可以从变量作用域的角度来理解。
     
     变量的常见作用域一般包括以下几种。
  • 函数内部变量。其作用区域是该函数,即每次调用该函数,该变量都会重新回到初始值。
  • 类内部的变量。其作用就是该类所产生的对象,即只要该对象没有被销毁,则对象内部的变量则一直保持。
  • 类内部的静态变量。其作用是整个进程,即只要在该进程中,该变量的值就会一直保持,无论使用多少类来构造这个对象,该变量只有一个赋值,且一直保持。
对于类内部的静态变量而言,无论是从进程中那个线程引用该变量,其值总是相同的,因为编译器内部为静态变量分配了单独的内存空间。但有时我们却希望,当从同一个线程中引用该变量时,其值总是相同的, 而从不同的线程引用该变量,其值应该不同,即我们需要一种作用域为线程的变量定义,这就是线程局部存储。

ThreadLocal内部其实是使用弱引用WeakReference来存储当前线程对象,但是不同的线程有不同的ThreadLocal对象,因此会有一个用于区别的id,由此内部封装了一个静态内部类Values,这个类就相当于一个map,存储了每一个线程的实例的值。

sThreadLocal在prepare()函数被调用的时候就进行了一次赋值,即构造一个新的Looper对象存储到本地线程局部变量中,当然一个线程只能有一个Looper对象,否则会抛出如下图所示的异常。

          技术分享

Looper中有2个用于构造Looper对象的方法。一个是prepare(),另一个是prepareMainLooper()。
prepare()我们已经说过了,下面说下prepareMainLooper()。
技术分享
prepareMainLooper(),由方法注释我们可以知道,这个应用程序的mainlooper对象是由android环境创建的,所以你自己永远没必要调用这个函数。
               技术分享
技术分享
2. Looper

我们可以从类注释来了解Looper类的作用到底是干什么的。

Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare in the thread that is to run the loop, and then loop to have it process messages until the loop is stopped.

Most interaction with a message loop is through the Handler class.

This is a typical example of the implementation of a Looper thread, using the separation of prepare and loop to create an initial Handler to communicate with the Looper.

  class LooperThread extends Thread {
      public Handler mHandler;

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }
Looper类的作用就是给在线程内部创建一个消息循环,当然线程自身内部是没有一个消息循环机制;在run()函数首行调用Looper.prepare(),即使创建了一个消息循环队列,然后在run函数尾行调用Looper.loop()则开始处理消息直到消息循环停止。
大多数消息循环的交互是通过Handler类进行的。


3. Handler

这里我们只从消息循环机制角度来分析这个Handler。首先看Handler的构造函数
/**
     * Default constructor associates this handler with the queue for the
     * current thread.
     *
     * If there isn‘t one, this handler won‘t be able to receive messages.
     */
    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());
            }
        }
         //从TLS(局部线程存储)中取出已经存放好的Looper对象
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can‘t create handler inside thread that has not called Looper.prepare()");
        }
        //将Looper对象中的MessageQueue赋值给Handler中的对象
        mQueue = mLooper.mQueue;
        mCallback = null;
    }

然后我们在从使用的角度分析,这里我只从异步处理UI界面分析。
我们(程序员)通过 Handler调用sendMessage()函数在线程内部向UI主线程发送一个Message对象,该Message对象会依次通过Handler中的函数
sendMessage(...) -> sendMessageDelayed(...) -> sendMessageAtTime(...) 
最终会通过sendMessageAtTime发送消息对象。
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            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;
    }

然后我们在来看看enqueueMessage进行了什么操作。

    final  boolean enqueueMessage(Message msg, long when) {
                      ...

        if (needWake) {
            nativeWake(mPtr);
        }

                      ...
   }

nativeWake是一个java本地方法,这里涉及了消息机制中的Sleep-Wakeup机制,关于如何唤醒Looper线程的动作,这里不做赘述,其最终就是调用了 native层的Looper的wake函数,唤醒了这个函数之后,就开始进行消息循环
 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。