handler

 

画图说明：

 

我在学习和使用handler的时候，对与它相关的源代码进行的研究，说到handler机制，就要设计到5个类（画图），

Handler、MessageQueue、Looper、Thread、还有一个Message；

Message是消息，它由MessageQueue统一列队，由Handler处理。

Handler是处理者，他负责发送和处理Message消息。

MessageQueue指消息队列，它用来存放Handler发送过来的队列，而且按照先入先出的规则执行。

Looper的做用就像抽水的水泵，它不断的从MessageQueue中去抽取Message并执行。

Thread线程，是消息循环的执行场所。

知道了这几个类就能够说说消息机制的原理了，在建立Activity以前，当系统启动的时候，先加载ActivityThread这个类，在这个类的main函数中，调用Looper.prepareMainLooper()进行初始化Looper对象，而后建立主线程的handler对象，随后才建立ActivityThread对象，最后调用Looper.loop()方法，不断的进行轮询消息队列中的消息。也就是说，在ActivityThread和Activity建立以前，就已经开启了Looper的loop()方法，不断的进行轮询消息。

咱们能够画图来讲明handler机制的原理：

咱们经过Message.obtain()准备消息数据以后，

第一步是使用sendMessage()：经过Handler将消息发送给消息队列

第二步、在发送消息的时候，使用message.target=this为handler发送的message贴上当前handler的标签

第三步、开启HandlerThread线程，执行run方法。

四、在HandlerThread类的run方法中开启轮询器进行轮询：调用Looper.loop()方法进行轮询消息队列的消息

五、在消息队列MessageQueue中enqueueMessage(Message msg, long when)方法里，对消息进行入列，即依据传入的时间进行消息入列（排队）

六、轮询消息：与此同时，Looper在不断的轮询消息队列

七、在Looper.loop()方法中，获取到MessageQueue对象后，从中取出消息（Message msg = queue.next()），若是没有消息会堵塞

八、分发消息：从消息队列中取出消息后，调用msg.target.dispatchMessage(msg);进行分发消息

九、将处理好的消息分发给指定的handler处理，即调用了handler的dispatchMessage(msg)方法进行分发消息。

十、在建立handler时，复写的handleMessage方法中进行消息的处理

十一、回收消息：在消息使用完毕后，在Looper.loop()方法中调用msg.recycle()，将消息进行回收，即将消息的全部字段恢复为初始状态。

 12. what带字段,obj带数据,   建立方法 new Message 或 Message.obtain()

 

 

handler机制？即handler的做用

在Android的UI开发中，咱们常常会使用Handler来控制主UI程序的界面变化。有关Handler的做用，

咱们总结为：与其余线程协同工做，接收其余线程的消息并经过接收到的消息更新主UI线程的内容。

咱们假设在一个UI界面上面，有一个按钮，当点击这个按钮的时候，会进行网络链接，并把网络上的一个字符串拿下来显示到界面上的一个 TextView上面，这时就出现了一个问题，若是这个网络链接的延迟过大，多是10秒钟甚至更长，那咱们的界面将处于一直假死状态，而若是这段时间超 过5秒钟的话，程序会出现异常。

这时咱们会想到使用线程来完成以上工做，即当按钮被按下的时候新开启一个线程来完成网络链接工做，并把获得的结果更新到UI上面。可是，这时候又会 出现另外一个问题，在Android中，主线程是非线程安全的，也就是说UI的更新只能在本线程中完成，其余线程没法直接对主线程进行操做。

为了解决以上问题，Android设计了Handler机制，由Handler来负责与子线程进行通信，从而让子线程与主线程之间创建起协做的桥梁，使Android的UI更新的问题获得完美的解决。接下来ATAAW.COM举例来诠释Handler的基本使用方法。

A、Handler的工做原理

通常状况下，在主线程中咱们绑定了Handler，并在事件触发上面建立新的线程用于完成某些耗时的操做，当子线程中的工做完成以后，会对Handler发送一个完成的信号，而Handler接收到信号后，就进行主UI界面的更新操做。

B、Handler与子线程协做实例

一、建立Handler实现类，在主UI所在类中的内部类

1     class MyHandler extends Handler {   

2     public MyHandler() {   

1        }   

1     public MyHandler(Looper L) {   

1     super(L);   

1        }   

1        // 重写handleMessage方法,接受数据并更新UI   

1        @Override   

1     public void handleMessage(Message msg) {   

2     super.handleMessage(msg);   

1        //此处根据msg内容进行UI操做   

1            }   

1        } 

二、子线程的实现

1     class MyThread implements Runnable {   

1     public void run() {   

1                Message msg = new Message();   

1                Bundle b = new Bundle();  

1                b.putString("cmd", "update");   

1                msg.setData(b);   

1                MainActivity.this.myHandler.sendMessage(msg);//通知Handler更新UI   

2            }   

1        } 

经过以上的两个实现，咱们只须要在MainActivity中声明MyHandler实例对象就能够完成线程之间的通信和界面的更新操做。

MyHandler myHandler = newMyHandler(); 

 

调用流程

• Message类的obtain方法

  • 消息队列顺序的维护是使用单链表的形式来维护的

  • 把消息池里的第一条数据取出来，而后把第二条变成第一条

    if (sPool != null) { Message m = sPool; sPool = m.next; m.next = null; sPoolSize--; return m; }

• 建立Handler对象时，在构造方法中会获取Looper和MessageQueue的对象

  public Handler() {
      ...
      //拿到looper
      mLooper = Looper.myLooper();
      ...
      //拿到消息队列
      mQueue = mLooper.mQueue;
      mCallback = null;
  }

• 查看myLooper方法体，发现Looper对象是经过ThreadLocal获得的，在查找ThreadLocal的set方法时发现

  • Looper是直接new出来的，而且在Looper的构造方法中，new出了消息队列对象

    sThreadLocal.set(new Looper());
    
    private Looper() {
        mQueue = new MessageQueue();
        mRun = true;
        mThread = Thread.currentThread();
    }

  • sThreadLocal.set(new Looper())是在Looper.prepare方法中调用的

• prepare方法是在prepareMainLooper()方法中调用的

  public static final void prepareMainLooper() {
      prepare();
      ...
  }

• 在应用启动时，主线程要被启动，ActivityThread会被建立，在此类的main方法中

  public static final void main(String[] args) {
      ...
      //建立Looper和MessageQueue
      Looper.prepareMainLooper();
      ...
      //轮询器开始轮询
      Looper.loop();
      ...
  }

• Looper.loop()方法中有一个死循环

  while (true) {
      //取出消息队列的消息，可能会阻塞
      Message msg = queue.next(); // might block
      ...
      //解析消息，分发消息
      msg.target.dispatchMessage(msg);
      ...
  }

• Linux的一个进程间通讯机制：管道（pipe）。原理：在内存中有一个特殊的文件，这个文件有两个句柄（引用），一个是读取句柄，一个是写入句柄

• 主线程Looper从消息队列读取消息，当读完全部消息时，进入睡眠，主线程阻塞。子线程往消息队列发送消息，而且往管道文件写数据，主线程即被唤醒，从管道文件读取数据，主线程被唤醒只是为了读取消息，当消息读取完毕，再次睡眠

• Handler发送消息，sendMessage的全部重载，实际最终都调用了sendMessageAtTime

  public boolean sendMessageAtTime(Message msg, long uptimeMillis)
  {
     ...
      //把消息放到消息队列中
      sent = queue.enqueueMessage(msg, uptimeMillis);
     ...
  }

• enqueueMessage把消息经过从新排序放入消息队列

  final boolean enqueueMessage(Message msg, long when) {
      ...
      final boolean needWake;
      synchronized (this) {
         ...
          //对消息的从新排序，经过判断消息队列里是否有消息以及消息的时间对比
          msg.when = when;
  
          Message p = mMessages;
          //把放入消息队列的消息置为消息队列第一条消息
          if (p == null || when == 0 || when < p.when) {
              msg.next = p;
              mMessages = msg;
              needWake = mBlocked; // new head, might need to wake up
          } else {
              //判断时间顺序，为刚放进来的消息寻找合适的位置
              Message prev = null;
              while (p != null && p.when <= when) {
                  prev = p;
                  p = p.next;
              }
              msg.next = prev.next;
              prev.next = msg;
              needWake = false; // still waiting on head, no need to wake up
          }
      }
      //唤醒主线程
      if (needWake) {
          nativeWake(mPtr);
      }
      return true;
  }

• Looper.loop方法中，获取消息，而后分发消息

  //获取消息队列的消息
   Message msg = queue.next(); // might block
   ...
  //分发消息，消息由哪一个handler对象建立，则由它分发，并由它的handlerMessage处理  
   msg.target.dispatchMessage(msg);

• message对象的target属性，用于记录该消息由哪一个Handler建立，在obtain方法中赋值