Android更新UI的四种方法详解

前言

相信每位android开发者们都知道更新ui只能在主线程中进行，若是在子线程执行任务后需要更新ui，则需要借助handler跳转到主线程中。以下介绍几种操作ui的方法。

一、使用handler的handlemessage()

handler的构造

public handler() {
this(null, false);
}

public handler(callback callback, boolean async) {
 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 followinghandler class should be static or leaks might occur: " + 
       klass.getcanonicalname()); 
   } 
 } 
 mlooper = looper.mylooper(); 
 if (mlooper == null) { 
   throw new runtimeexception( 
     "can't create handler insidethread that has not called looper.prepare()"); 
 } 
 mqueue = mlooper.mqueue; 
 mcallback = null; 
}

可见构造handler需要looper,没有的话会抛出异常。looper.mylooper()


会返回一个looper对象，怎么返回呢，看下源码

public static finallooper mylooper() { 
 return (looper)sthreadlocal.get(); 
}

显然，mylooper()从threadlocal中取出了looper对象。那么问题来了，我们又是什么时候将looper对象存进threadlocal呢？其实奥秘在于我们调用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对象。

由此可见，当实例化一个hanlder之前需要先调用looper.prepare() ,否则会抛出异常，除非是主线程中构建handler。因为主线程在创建的时候系统已经为其建立了一个looper。

message的创建

一般情况最普遍的做法就是

message message = new message();  
mhandler.sendmessage(message);

但这么做的话每次都需要new一个message，比较浪费空间，我们可以使用obtainmessage()；看一下源码

public final message obtainmessage(int what, int arg1, int arg2, object obj){ 
  return message.obtain(this, what, arg1,arg2, obj); 
}

这个方法返回了message.obtain(this, what, arg1,arg2, obj) ，也就是说和obtainmessage()作用一样，所以也可以直接使用message.obtain(this, what, arg1,arg2, obj) 。

再看obtain()的源码

public static message obtain(handler h, int what, int arg1, int arg2, object obj) { 
   message m = obtain(); 
   m.target = h; 
   m.what = what; 
   m.arg1 = arg1; 
   m.arg2 = arg2; 
   m.obj = obj; 
   return m; 
}

看上面的代码我们还得找到obtain的无参构造

public static message obtain() { 
   synchronized (spoolsync) { 
     if (spool != null) { 
       message m = spool; 
       spool = m.next; 
       m.next = null; 
       m.flags = 0; // clear in-useflag 
       spoolsize--; 
       return m; 
     } 
   } 
   return new message(); 
 }

不难看出，obtain从消息池中返回了一个message对象，如果消息池为空再创建一个新的消息，所以一般使用obtain()得到一个消息比较合理。

message的参数

public int arg1

public int arg2

如果只需要存储整型数据，使用arg1 和 arg2即可

public object obj

发送给接收器的任意对象。当使用message对象在线程间传递消息时，如果它包含一个parcelable的结构类（不是由应用程序实现的类），此字段必须为非空（non-null）。

public int what

用户自定义的消息代码，这样接受者可以了解这个消息的信息。每个handler各自包含自己的消息代码，所以不用担心自定义的消息跟其他handlers有冲突。

如果需要传递bundle对象，则使用setdata(bundle)

public handler target

接收此消息的handler对象。

处理消息的几个方法

public final boolean sendmessage(message msg){
  return sendmessagedelayed(msg, 0);//直接调用sendmessagedelayed()，只是没有时间延迟
}
public final boolean sendmessagedelayed(message msg, long delaymillis){
  if (delaymillis < 0) {
    delaymillis = 0;
  } 
  return sendmessageattime(msg, systemclock.uptimemillis() + delaymillis);//调用sendmessageattime，当前时间加上延迟时间。
}

public boolean sendmessageattime(message msg, long uptimemillis) { 
 messagequeue queue = mqueue;  
 if (queue == null) {    
  runtimeexception e = new runtimeexception(this + " sendmessageattime() called with no mqueue");    
  log.w("looper", e.getmessage(), e);    
  return false;  
 }  
 return enqueuemessage(queue, msg, uptimemillis);//调用enqueuemessage,附上消息队列和时间
}
private boolean enqueuemessage(messagequeue queue, message msg, long uptimemillis) {
 msg.target = this;  
 if (masynchronous) {    
  msg.setasynchronous(true);  
 }  
 return queue.enqueuemessage(msg, uptimemillis);//最后调用队列的插入消息方法，只是插入的时间有制定。
}

通过上面的分析，不管handler调用哪个sendmessage()的方法，最后都是将消息插入队列而已，没有其他操作。通过queue.enqueuemessage(msg, uptimemillis这个方法我们也知道looper处理消息的顺序是根据消息插入的时间快慢来轮询。

补充一下空消息的方法

public final boolean sendemptymessage(int what){
  return sendemptymessagedelayed(what, 0);
}
public final boolean sendemptymessagedelayed(int what, long delaymillis) { 
message msg = message.obtain(); 
msg.what = what; 
return sendmessagedelayed(msg, delaymillis); 
}

二、handler的post()方法

使用步骤

handler.post(new runnable() { 
      @override 
      public void run() { 
        //这里就可以进行ui操作。
      } 
    });

来看下post方法的源码

public final boolean post(runnable r){ 
  return sendmessagedelayed(getpostmessage(r), 0); 
}

看到这里是不是就恍然大悟了，原来post方法其实也是发送了一则消息。

再看getpostmessage(r)的源码

private final message getpostmessage(runnable r) {
  message m = message.obtain();
  m.callback = r;
  return m;
}

这下一清二楚了，这个方法将runnable对象封装为message，然后sendmessagedelayed发送过去给handler处理。

这里我们要先知道消息是如何被取出来的，当前messagequeue中存在mmessages(即待处理消息)，就把这个消息取出来，然后让下一条消息成为mmessages，否则就进入一个阻塞状态，一直等到有新的消息入队。每当有一个消息取出，就将它传递到msg.target的dispatchmessage()中，这个msg.target是handler的enqueuemessage方法中的msg.target = this语句，也就是当前handler对象。所以接下来的重点自然就是回到dispatchmessage(）

public void dispatchmessage(message msg) { 
  if (msg.callback != null) { 
    handlecallback(msg); 
  } else { 
    if (mcallback != null) { 
      if (mcallback.handlemessage(msg)) { 
        return; 
      } 
    } 
    handlemessage(msg); 
  } 
}

如果调用了handler.post()方法，则callback != null ，所以执行了 handlecallback(msg);方法

private final void handlecallback(message message) {
  message.callback.run();
}

也就是最终runnable对象被handle处理了。根据handler的原理，handler需要实例化在主线程post方法才能更新ui。

三、view的post方法

看下源码

public boolean post(runnable action) {
  handler handler;
  if (mattachinfo != null) {
    handler = mattachinfo.mhandler;
  } else {
    viewroot.getrunqueue().post(action);
    return true;
  }
  return handler.post(action);
}

一目了然，调用handlerd的post方法，本质是一样的。

四、activity中的runonuithread()方法

public final void runonuithread(runnable action) { 
  if (thread.currentthread() != muithread) { 
    mhandler.post(action); 
  } else { 
    action.run(); 
  } 
}

这个方法想必没什么好说的，如果是ui线程，直接run，不是的话借助handler.post（）
有一点要注意，这个方法只能运行在activity中。

总结

以上就是这篇文章的全部内容了，希望能对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流。