Android消息机制源码解析（一）——消息的载体Message

说到Android的消息机制，大家再熟悉不过了，几乎每个逻辑界面中都会涉及到，Activity的生命周期回调也是通过系统消息机制完成的，可见消息机制在Android中的重要性。在应用层，一般我们都是使用Handler来发送、处理消息，从工作线程切换到主线程来更新UI。往往开发者只跟Handler、Message打交道就能满足需求了，但它们背后的实现原理是怎样的呢？为了加深理解，深入学习Android设计理念，同时也希望给初学者带来一些帮助，下面会从源码角度来分析Android的消息机制，鉴于篇幅原因，大致分为如下四个小节：

1.Andorid消息的载体Message

2.Android消息的执行者Handler

3.Android消息的循环器Looper

4.Android消息队列MessageQueue

直入正题，先来看Android消息的载体——Message。

一、大家都知道Handler发送的是消息，这里的消息对应的正是Message对象，来看一下源码中Message的定义与实现。

public final class Message implements Parcelable

首先可以看到Message实现了Parcelable接口，那么接下来就必然会实现序列化需要的几个方法，序列化部分代码不需要过多解释，具体如下：

public static final Parcelable.Creator<Message> CREATOR
            = new Parcelable.Creator<Message>() {
        public Message createFromParcel(Parcel source) {
            Message msg = Message.obtain();
            msg.readFromParcel(source);
            return msg;
        }
        
        public Message[] newArray(int size) {
            return new Message[size];
        }
    };
        
    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {
        if (callback != null) {
            throw new RuntimeException(
                "Can't marshal callbacks across processes.");
        }
        dest.writeInt(what);
        dest.writeInt(arg1);
        dest.writeInt(arg2);
        if (obj != null) {
            try {
                Parcelable p = (Parcelable)obj;
                dest.writeInt(1);
                dest.writeParcelable(p, flags);
            } catch (ClassCastException e) {
                throw new RuntimeException(
                    "Can't marshal non-Parcelable objects across processes.");
            }
        } else {
            dest.writeInt(0);
        }
        dest.writeLong(when);
        dest.writeBundle(data);
        Messenger.writeMessengerOrNullToParcel(replyTo, dest);
        dest.writeInt(sendingUid);
    }

    private void readFromParcel(Parcel source) {
        what = source.readInt();
        arg1 = source.readInt();
        arg2 = source.readInt();
        if (source.readInt() != 0) {
            obj = source.readParcelable(getClass().getClassLoader());
        }
        when = source.readLong();
        data = source.readBundle();
        replyTo = Messenger.readMessengerOrNullFromParcel(source);
        sendingUid = source.readInt();
    }
}

二、下面重量级的嘉宾开始登场了，之所以把Message称为消息的载体，是因为Message是对消息内容的一个封装，根据平时的开发经验，大家知道Message可以传递一些数据，比如整型、Bundle以及Object，那么Message为什么拥有这种能力呢？来看下Message的几个重要属性字段：

public int what;

public int arg1;

public int arg2;

public Object obj;

/*package*/ long when;
/*package*/ Bundle data;
/*package*/ Handler target;
/*package*/ Runnable callback;

相信大家对前边几个字段非常熟悉，what是开发者自定义的一个整型标识，作用就是接收者（接收者就是Handler了）收到消息时可以知道此消息的来源与用途；有时候一个消息仅需要简单传递一些轻量级的整数，此时arg1和arg2就可以派上用场了，从而不必使用Bundle，可以节省开销；Message还可以利用Object来传递任意数据，但在用于进程间通讯时，如object实现了Parceable则必须保证不为空；当然最常用的是通过Bundle来传递数据了，即上面第6个字段；when用来存储消息何时执行；target实际上是一个Handler,表示该消息是由谁发送的；此外Message还有一个callback字段，本质上是一个Runnable，用来支持发送Runnable类型的消息，如Handler中的方法：

public final boolean post(Runnable r)

参数Runnable最终被赋给消息的上述callback字段。

Android中的Message对象是按链表结构存储的，这样就可以利用消息池，从而减少对象的创建，提高性能，具体有如下相关字段：

/*package*/ Message next;
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
private static boolean gCheckRecycle = true;

从字段名称很容易理解，sPool可以理解为消息链表的头部，next指向下一条消息，其中默认消息池初始值为0，最大容量为50；gCheckRecycle是一个用来辅助回收消息的辅助变量。

此外，Message还有如下两个字段：

public Messenger replyTo;

public int sendingUid = -1;

这两个字段是用来进程间通讯的，这里就不再展开。

三、Message的主要属性字段都介绍完了，那么如何创建一个Message呢？尽管Message提供了public的无参构造函数，但是并不建议通过构造函数创建Message对象。很多无经验的开发者往往会new一个Message，这是不可取的，应该特别注意。Message类为我们提供了obtain()及多个同名方法来从消息池中获取一个Message，这样就可以利用消息池中回收的对象，避免重新创建对象，以节省开销。来看一下obtain()方法：

public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

代码很简单，synchronized是用来保证线程同步的，上述代码仅在消息池中没有可用对象时才通过无参构造方法创建对象，否则就从消息池中返回一个Message对象。obtain()其他同名方法原理也一样，只不过会将参数赋值给获取到的Message各个字段（最初提到的what、arg1、arg2、obj、target等属性字段），如带Handler参数的obtain()方法：

public static Message obtain(Handler h) {
    Message m = obtain();
    m.target = h;

    return m;
}

如带有Handler、what、obj三个参数的obtain()方法：

public static Message obtain(Handler h, int what, Object obj) {
    Message m = obtain();
    m.target = h;
    m.what = what;
    m.obj = obj;

    return m;
}

其他类似，就不再一一列举。

分析到这里，事先提一下，除了使用Message类的obtain()相关方法获取消息对象之外，也可以使用Handler类提供的obtainMessage()系列方法，其内部实现则是调用了Message的obtain()系列方法，等第二节讲到Handler时会详细说明。

四、Message类提供了几个set方法，如：

public void setTarget(Handler target) {
    this.target = target;
}

如果obtain()方法中没有传递Handler参数，则可以使用上述方法设置，明确该消息由谁来发送和接收。指定消息的Handler后，还有一个sendToTarget():

/**
 * Sends this Message to the Handler specified by {@link #getTarget}.
 * Throws a null pointer exception if this field has not been set.
 */
public void sendToTarget() {
    target.sendMessage(this);
}

注释已经写的很清楚了，如果一个消息未指定Handler，则调用此方法会报空指针。我们在开发时需要发送一个消息，往往会这样写：

Message message = Message.obtain(mHandler, what, obj);

message.sendToTarget();

sendToTarget()实际上会调用Handler中发送消息的方法，最终会将消息添加到一个队列中，当然发送消息也可以直接使用Handler的sendMessage系列方法，这些内容在后面会详细介绍。

如果需要使用Bundle来发送消息，那么当封装好Bundle后，可以利用以下方法将Bundle保存到消息中：

public void setData(Bundle data) {
    this.data = data;
}

同样Message类还提供了一系列获取对象属性的方法，如：

public long getWhen() {
    return when;
}

上述方法返回消息的执行时间。

public Handler getTarget() {
    return target;
}

上述方法返回发送、接收消息的Handler对象。

public Runnable getCallback() {
    return callback;
}

上述方法返回Runnable对象。

public Bundle getData() {
    if (data == null) {
        data = new Bundle();
    }
    
    return data;
}

此方法返回一个Bundle,如果为空则会创建一个新的对象返回。

public Bundle peekData() {
    return data;
}

此方法则不管Bundle是否为空，直接返回。

五、接下来再看一下消息回收的源码实现：

/**
 * Recycles a Message that may be in-use.
 * Used internally by the MessageQueue and Looper when disposing of queued Messages.
 */
void recycleUnchecked() {
    // Mark the message as in use while it remains in the recycled object pool.
    // Clear out all other details.
    flags = FLAG_IN_USE;
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = -1;
    when = 0;
    target = null;
    callback = null;
    data = null;

    synchronized (sPoolSync) {
        if (sPoolSize < MAX_POOL_SIZE) {
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

代码比较容易理解，就是消息的各个属性置为初始值，同时消息池数量在未超限时加1。

六、最后简单说一下异步消息，一般情况下发送的消息都是同步的，在某些情况下可能会用到异步消息，比如View的刷新。异步消息顾名思义，它不会受同步消息的顺序限制，因此可能引发不可预知的情况，所以建议慎用。如果需要将某个消息设置为异步执行，可调用如下方法：

public void setAsynchronous(boolean async) {
    if (async) {
        flags |= FLAG_ASYNCHRONOUS;
    } else {
        flags &= ~FLAG_ASYNCHRONOUS;
    }
}

其中flag是一个int型的标识字段，如果想判断某个消息是否为异步消息，调用如下方法：

public boolean isAsynchronous() {
    return (flags & FLAG_ASYNCHRONOUS) != 0;
}

Message源码比较简单，逻辑也很清楚，总结一下，主要是Message的一些重要的属性字段、Message的链表特性以及如何利用obtain()系列方法高效创建一个Message对象等。Android消息的载体Message我们已经彻底搞清楚了，那么这些构造好的消息又是如何发送出去的呢，它们又是如何被接收和处理的？请看《Android消息机制源码解析（二）——消息的执行者Handler》。