欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

Android Handler 原理分析及实例代码

程序员文章站 2024-02-13 15:30:10
android handler 原理分析 handler一个让无数android开发者头疼的东西,希望我今天这边文章能为您彻底根治这个问题 今天就为大家详细剖析下han...

android handler 原理分析

handler一个让无数android开发者头疼的东西,希望我今天这边文章能为您彻底根治这个问题

今天就为大家详细剖析下handler的原理

handler使用的原因

1.多线程更新ui会导致ui界面错乱
2.如果加锁会导致性能下降
3.只在主线程去更新ui,轮询处理

handler使用简介

其实关键方法就2个一个sendmessage,用来接收消息

另一个是handlemessage,用来处理接收到的消息

下面是我参考疯狂android讲义,写的一个子线程和主线程之间相互通信的demo

对原demo做了一定修改

public class mainactivity extends appcompatactivity { 
  public final static string upper_num="upper_num"; 
  private edittext edittext; 
  public jisuanthread jisuan; 
  public handler mainhandler; 
  private textview textview; 
  class jisuanthread extends thread{ 
    public handler mhandler; 
    @override 
    public void run() { 
      looper.prepare(); 
      final arraylist<integer> al=new arraylist<>(); 
      mhandler=new handler(){ 
        @override 
        public void handlemessage(message msg) { 
 
          if(msg.what==0x123){ 
            bundle bundle=msg.getdata(); 
            int up=bundle.getint(upper_num); 
            outer: 
            for(int i=3;i<=up;i++){ 
              for(int j=2;j<=math.sqrt(i);j++){ 
                if(i%j==0){ 
                  continue outer; 
                } 
              } 
              al.add(i); 
            } 
            message message=new message(); 
            message.what=0x124; 
            bundle bundle1=new bundle(); 
            bundle1.putintegerarraylist("result",al); 
            message.setdata(bundle1); 
            mainhandler.sendmessage(message); 
          } 
        } 
      }; 
      looper.loop(); 
    } 
  } 
  @override 
  protected void oncreate(bundle savedinstancestate) { 
    super.oncreate(savedinstancestate); 
    setcontentview(r.layout.activity_main); 
    edittext= (edittext) findviewbyid(r.id.et_num); 
    textview= (textview) findviewbyid(r.id.tv_show); 
    jisuan=new jisuanthread(); 
    jisuan.start(); 
    mainhandler=new handler(){ 
      @override 
      public void handlemessage(message msg) { 
        if(msg.what==0x124){ 
          bundle bundle=new bundle(); 
          bundle=msg.getdata(); 
          arraylist<integer> al=bundle.getintegerarraylist("result"); 
          textview.settext(al.tostring()); 
        } 
      } 
    }; 
    findviewbyid(r.id.bt_jisuan).setonclicklistener(new view.onclicklistener() { 
      @override 
      public void onclick(view v) { 
        message message=new message(); 
        message.what=0x123; 
        bundle bundle=new bundle(); 
        bundle.putint(upper_num, integer.parseint(edittext.gettext().tostring())); 
        message.setdata(bundle); 
        jisuan.mhandler.sendmessage(message); 
      } 
    }); 
  } 
} 

hanler和looper,messagequeue原理分析

1.handler发送消息处理消息(一般都是将消息发送给自己),因为hanler在不同线程是可使用的

2.looper管理messagequeue

looper.loop死循环,不断从messagequeue取消息,如果有消息就处理消息,没有消息就阻塞

public static void loop() { 
    final looper me = mylooper(); 
    if (me == null) { 
      throw new runtimeexception("no looper; looper.prepare() wasn't called on this thread."); 
    } 
    final messagequeue queue = me.mqueue; 
    // make sure the identity of this thread is that of the local process, 
    // and keep track of what that identity token actually is. 
    binder.clearcallingidentity(); 
    final long ident = binder.clearcallingidentity(); 
 
    for (;;) { 
      message msg = queue.next(); // might block 
      if (msg == null) { 
        // no message indicates that the message queue is quitting. 
        return; 
      } 
      // this must be in a local variable, in case a ui event sets the logger 
      printer logging = me.mlogging; 
      if (logging != null) { 
        logging.println(">>>>> dispatching to " + msg.target + " " + 
            msg.callback + ": " + msg.what); 
      } 
      msg.target.dispatchmessage(msg); 
 
      if (logging != null) { 
        logging.println("<<<<< finished to " + msg.target + " " + msg.callback); 
      } 
      // make sure that during the course of dispatching the 
      // identity of the thread wasn't corrupted. 
      final long newident = binder.clearcallingidentity(); 
      if (ident != newident) { 
        log.wtf(tag, "thread identity changed from 0x" 
            + long.tohexstring(ident) + " to 0x" 
            + long.tohexstring(newident) + " while dispatching to " 
            + msg.target.getclass().getname() + " " 
            + msg.callback + " what=" + msg.what); 
      } 
 
      msg.recycleunchecked(); 
    } 
  } 

这个是looper.loop的源码,实质就是一个死循环,不断读取自己的messqueue的消息

3.messqueue一个消息队列,handler发送的消息会添加到与自己内联的looper的messqueue中,受looper管理

private looper(boolean quitallowed) { 
    mqueue = new messagequeue(quitallowed); 
    mthread = thread.currentthread(); 
  } 

这个是looper构造器,其中做了2个工作,

1.生成与自己关联的message

2.绑定到当前线程

主线程在初始化的时候已经生成looper,

其他线程如果想使用handler需要通过looper.prepare()生成一个自己线程绑定的looper

这就是looper.prepare()源码,其实质也是使用构造器生成一个looper

private static void prepare(boolean quitallowed) { 
    if (sthreadlocal.get() != null) { 
      throw new runtimeexception("only one looper may be created per thread"); 
    } 
    sthreadlocal.set(new looper(quitallowed)); 
  } 

4.handler发送消息会将消息保存在自己相关联的looper的messagequeue中,那它是如何找到这个messagequeue的呢

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

这个是handler的构造方法,它会找到一个自己关联的一个looper

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

没错,他们之间也是通过线程关联的,得到looper之后自然就可以获得它的messagequeue了

5.我们再看下handler如发送消息,又是如何在发送完消息后,回调handlermessage的

private boolean enqueuemessage(messagequeue queue, message msg, long uptimemillis) { 
    msg.target = this; 
    if (masynchronous) { 
      msg.setasynchronous(true); 
    } 
    return queue.enqueuemessage(msg, uptimemillis); 
  } 

这个就是handler发送消息的最终源码,可见就是将一个message添加到messagequeue中,那为什么发送完消息又能及时回调handlemessage方法呢

大家请看上边那个loop方法,其中的for循环里面有一句话msg.target.dispatchmessage(msg);

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

这就是这句话,看到了吧里面会调用hanlermessage,一切都联系起来了吧

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!