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 原理分析和使用（二）