Android中利用Handler实现消息的分发机制（零）

标签：handler   android   异步消息处理机制   message   messagequeue   

在之前一篇介绍AsyncTask的文章中，我们在最后讲到，AsyncTask是利用Handler的消息异步处理机制，将操作结果，利用Message传回主线程，从而进行UI线程的更新的。

而在我们日常的开发工作中，Handler也是我们经常使用的类之一，那么Handler的主要作用是什么？

Handler 的主要作用就是对消息（消息可以是我们想做的一些UI更新，也可以是其他的一些不可见的操作，如操作数据库等）的异步处理机制，而相信大家都了解异步的概念。

简单地说一下：

1）从程序的角度来看，就是当执行某行代码的时候，发送了一个异步请求（消息），程序不需要在此行代码上继续等待下去，而是能够继续执行之后的代码。

2）从用户的角度来看，用户发送了一个消息，不需要什么事也不做，就在那傻等，而可以去做其他的事情，当对应的消息被处理完之后 ，就会通过回调机制处理对应的结果。

所以，Android中Handler的消息异步处理机制，能够给用户提供一个更加合理及友好的用户体验。当然，Android是用Handler来实现，其他的平台环境，也有着自己的一套异步实现机制，原理一样，名称不同而已。

既然我们是做Android开发的，那么我们肯定就要好好地学习一下Handler的使用，探究一下隐藏在Handler之后的代码架构。

首先，我们还是从简单的例子来入门，学习一下，如何使用Handler。

代码如下：

public class MainActivity extends ActionBarActivity {

    private static final int MSG_ID_1 = 1;
    private static final int MSG_ID_2 = 2;

    private Handler mHandler = new Handler() {

        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MSG_ID_1:
                Log.v("Test", "Toast called from Handler.sendMessage()");
                break;
            case MSG_ID_2:
                break;
            }
            
        }
    };
    
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Message message = mHandler.obtainMessage();
        message.what = MSG_ID_1;
        mHandler.sendMessage(message);
    }
}

10-27 15:13:21.382: V/Test(9618): Toast called from Handler.sendMessage()

从这个简单的例子，我们可以归纳一下Handler的使用步骤，大概有以下几步：

1）创建一个Handler对象，并且实现其 handleMessage(Message msg) 方法，如代码中：

private Handler mHandler = new Handler() {

而实现handleMessage方法一步，我们可以看到，会获取一个Message对象。

Message对象封装了一些参数，常用的大概有以下几个：

a）what 参数：这是一个 int 值，经常是我们用来区分消息的一个ID，比如例子中，我们将MSG_ID_1在创建消息的时候赋值给msg.what。

b）obj 参数：这是一个Object对象。通过obj参数，可以把任何对象赋给消息，然后在handleMessage中进行处理，而这也是Handler在异步处理中传递数据的方法。

c）arg1， arg2 等参数：上述a)，b) 两个参数是我们最常用的Message的参数了，基本上也需要这两个参数就足够了，不过Message还是提供了其他的一些字段供我们使用，如argX等，也就是 arguments的缩写。

2）当创建好Handler对象之后，第二步就需要创建一个Message对象了，创建Message对象有两种方法：

2.1）直接创建新对象，代码如下：

Message msg = new Message()

Message message = mHandler.obtainMessage();

一般情况下，我们建议使用第二种方式，为什么呢？

因为在Message的内部中维护了一个类似消息池的对象，当我们使用Handler来对Message进行分发的时候，处理完之后，Message对象并不一定会被马上销毁，而是有可能放到一个消息池中。

当利用Handler的obtainMessage方法，Handler会去从消息池中获取一个已经存在的对象，并初始化好其信息，这样，我们就不需要再重新去创建一个对象，浪费一些内存，在嵌入式应用，内存不是很大的情况下，这是对性能的一种优化。

在创建Message的时候，我们就可以对msg.what进行赋值，目的就是为了Handler在handleMessage的时候，可以判断这个消息的用途或目的是什么。

当然，不同的需求，肯定有不同的处理，这就具体情况具体分析了。

3）当消息（Message）创建好了之后，我们就可以利用Handler的sendMessage来进行发送消息了，之后，这个消息就会被其handler所捕获，从而进行处理了。

接下来，我们就再扩充一下这个例子，代码如下：

public class MainActivity extends ActionBarActivity {

    private static final int MSG_ID_1 = 1;
    private static final int MSG_ID_2 = 2;

    private Handler mHandler = new Handler() {

        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MSG_ID_1:
                Log.v("Test", "Toast called from Handler.sendMessage()");
                break;
            case MSG_ID_2:
                String str = (String) msg.obj;
                Log.v("Test", str);
                break;
            }
            
        }
    };
    
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Message message = mHandler.obtainMessage();
        message.what = MSG_ID_1;
        mHandler.sendMessage(message);
        
        Message msg2 = mHandler.obtainMessage();
        msg2.obj = "I'm String from Message 2";
        msg2.what = MSG_ID_2;
        mHandler.sendMessage(msg2);
    }
}

10-27 15:35:19.168: V/Test(12135): Toast called from Handler.sendMessage()
10-27 15:35:19.168: V/Test(12135): I'm String from Message 2

除了 sendMessage方法，发送消息时， Handler还可使用如下的方法：

    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

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

  
    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }

    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);
    }
    
    public final boolean sendMessageAtFrontOfQueue(Message msg) {
        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, 0);
    }

那么其为什么要放到MessageQueue？放到MessageQueue中有如何跑回到Handler的handleMessage中的呢？

接下来的文章，我们再继续来学习。

这一篇我们就简单地介绍了如何使用Handler，简单的例子，简单地入门。

结束。

Android中利用Handler实现消息的分发机制（零）

标签：handler   android   异步消息处理机制   message   messagequeue   

原文地址：http://blog.csdn.net/linmiansheng/article/details/40503791