Handler 原理分析和使用（一）

我为什么写Handler，原因主要还在于它在整个 Android 应用层面非常之关键，他是线程间相互通信的主要手段。最为常用的是其他线程通过Handler向主线程发送消息，更新主线程UI。

下面是一个最简单的例子。

 import android.os.Handler;

 import android.os.Looper;

 import android.os.Message;

 import android.os.MessageQueue;

 import android.support.v7.app.AppCompatActivity;

 import android.os.Bundle;

 import android.widget.TextView;

 public class MainActivity extends AppCompatActivity {

     private TextView myTextView;

     private Handler myHandler = new Handler(){

         @Override

         public void handleMessage(Message msg) {

             //UI线程接收到消息

             int arg1 = msg.arg1;

             switch (arg1){

                 case 0:

                     if(msg.arg2 == 0){

                         //更新UI

                         myTextView.setText((String)msg.obj);

                     }

                     break;

                 default:

                     break;

             }

             super.handleMessage(msg);

         }

     };

     @Override

     protected void onCreate(Bundle savedInstanceState) {

         super.onCreate(savedInstanceState);

         setContentView(R.layout.activity_main);

         myTextView = (TextView)this.findViewById(R.id.text_view);

         //起独立线程

         new Thread(){

             public void run(){

                 String text = "from handler";

                 Message message = new Message();

                 message.arg1 = 0;

                 message.arg2 = 0;

                 message.obj = text;

                 //通过Handler给UI发消息

                 myHandler.sendMessage(message);

             }

         }.start();

     }

 }

上面的例子看似好简单了。但是支持这样消息从一个线程传到另一个线程，不仅仅需要Handler这样一个类的支持，还需要其他类的支持，分别是 Looper， Message， MessageQueue。

消息的流转的架构：

Handler 负责发送消息和处理消息
Message 是消息的实体。
MessageQueue 消息队列。
Looper 负责消息队列的循环，包括两件事：第一创建和控制 MessageQueue；第二轮询MessageQueue读取Message信息派发给Handler

消息的流转的过程：

首先，在Android里面每一个线程都有自己的一个Looper。而每个Looper都有一个MessageQueue。

Looper对象不需要开发人员去初始化，在每个线程里面他是存在的。源码中初始化如下：

 private Looper(boolean quitAllowed) {

         mQueue = new MessageQueue(quitAllowed);

         mRun = true;

         mThread = Thread.currentThread();

 }

可见消息队列也是在此创建的。但是每个线程需要绑定自己的Looper，调用的方法是Looper.prepare(),源码实现如下

 public static final void prepare() {

         //此处说明prepare只能执行一次，再一次会抛异常

         if (sThreadLocal.get() != null) {

             throw new RuntimeException("Only one Looper may be created per thread");

         }

         //绑定Looper

         sThreadLocal.set(new Looper(true));

 }

其次，Handler对象可以跨线程，它在次线程中将Message推入MessageQueue中。

　　在Handler初始化时，就已经和自己所在的线程的MessageQueue绑定，源码如下

 public Handler() {

         this(null, false);

 }

 public Handler(Callback callback, boolean async) {

         ..............

         //获取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 = callback;

         mAsynchronous = async;

 }

　　绑定之后就可以向MessageQueue里面推入Message，源码如下：

 public final boolean sendMessage(Message msg)  {

      return sendMessageDelayed(msg, 0);

  }

 public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {

      Message msg = Message.obtain();

      msg.what = what;

      return sendMessageDelayed(msg, delayMillis);

  }

 public final boolean sendMessageDelayed(Message msg, long delayMillis)  {

        if (delayMillis < 0) {

            delayMillis = 0;

        }

        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

  }

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

  }

　　由上可以看出各种推Message的方法最后都归结到 enqueueMessage(...)方法中，该方法实现源码如下：

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

        //此处，Handler对象被Message对象标记起来，

        msg.target = this;

        if (mAsynchronous) {

            msg.setAsynchronous(true);

        }

        //压入MessageQueue里面。

        return queue.enqueueMessage(msg, uptimeMillis);

 }

再次，Looper发现MessageQueue有Message，于是获取该Message相应的Handler，并将Messager给Handler处理。

　　Looper又是如何发现MessageQueue里面的Message，并且分配给指定的Handler？答案是通过Looper.loop()方法，源码如下：

 public static void loop() {

         final Looper me = myLooper();

         if (me == null) {

             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

         }

         //获取到Looper对象的MessageQueued对象。

         final MessageQueue queue = me.mQueue;  

         .............

         //开始无限循环

         for (;;) {

             //从MessageQueue里面读取Message，如果消息暂时不被读取会被阻塞。

             Message msg = queue.next();

             if (msg == null) {

                 // No message indicates that the message queue is quitting.

                 //消息为空退出。

                 return;

             }  

            ............

             //此处给Message的target（也就是对应的Handler）指派消息。

             msg.target.dispatchMessage(msg);  

            ............

             //消息被回收

             msg.recycle();

         }

 }

最后，Handler处理该Messager

　　接上面的源码可知，最后Message又被它的发送者Handler进行处理，调用的方法是dispatchMessage(msg),该方法源码实现如下：

 public void dispatchMessage(Message msg) {

         if (msg.callback != null) {

             handleCallback(msg);

         } else {

             if (mCallback != null) {

                 if (mCallback.handleMessage(msg)) {

                     return;

                 }

             }

             //该方法会被重写，从而实现自定义的UI改动

             handleMessage(msg);

         }

  }

　　可以看出，最后调用到了handlerMessage(msg)方法，在通常的实践中，这个方法被重写，从而实现自定义的逻辑。

以上过程中需要注意。

Message对象本身存在于一个消息池中。如果消息池中有消息，建议不要使用new的方式产生对象应该复用该对象

 Message message = myHandler.obtainMessage();

 message.arg1 = 0;

 myHandler.sendMessage(message);

今天就到这吧。这只是一部分，明天再说另一部分。同样的作为进程间通信的开源组件EventBus也将被分析。

Handler 原理分析和使用（二）

巴特西

Handler 原理分析和使用（一）

最新文章

热门文章