android之handler异步消息处理机制解析-百家乐凯发k8

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;
 }