其实是想跟着书看的，自己先大概浏览了一下Handler的源码，关于Message、MessageQueue、Looper。然后又写了一下Handler在两个子线程之间传递Message的例子，发现服务端在接收消息的时候它所持有的Handler必须是static类型的才能在客户端获取到。这又让我想到才看的java虚拟机内存运行时的四大部分，Handler到底是在java堆中还是在java虚拟机栈中，好懵，总感觉自己看的东西不能和实际结合，问题出来总是不敢确定一个准确的答案。在写代码的过程中对sendToTarget和sendMessage两个方法又有点迷，到底是咋一回事，所以先把Message看看，看看这个类的一些重要的方法。

Message

Message的成员变量

1. 用于传递数据的变量

• public int what

what很常用，一般在handleMessage中通过调用msg.what来判断接收的消息是什么，也就是判断是哪个线程发过来的哪个类型的消息

• public int arg1
• public int arg2

arg1和arg2都是可以作为整数类型传递的。比方说msg.arg1=1;接收方int i = msg.arg1获得就可以。这两个我几乎没用过，因为有时候传的数据比较多，就放到Bundle里了，有这两个的原因就是一种低成本的方案，减少了使用创建Bundle对象，再通过setData方法去传递几个整数数据。

• public Object obj

Object可以传递任意类型的对象，我通常都用它传递了一个简单的字符串去更新ui线程的数据。

• public Messenger replyTo

这个通常在进程间通信的时候使用。Messenger作为信使传递的数据都是轻量级的。使用replyTo的时候一般是在服务器给客户端回信的时候需要获得客户端的Messenger,客户端在给服务器传递消息的时候可以通过msg.replyTo = mClientMessenger的方式传递给服务端，服务端拿到后就可以把消息传递给客户端了。

• Bundle data

Bundle传递数据用的比较多，这里就简单展示下。

//线程1
Bundle bundle = new Bundle();
bundle.putString("key","hello");
msg.setData(bundle);

//线程2
Bundle bundle = msg.getData();
String str = bundle.getString("key");

2. 其他变量

• static final int FLAG_IN_USE = 1 << 0:标记消息被使用
• static final int FLAG_ASYNCHRONOUS = 1 << 1：标记消息是异步的
• int flags:用来标记当前Message是否可用
• long when：发送之后，何时能被处理
• Handler target：表示消息被哪个handler处理
• Runnable callback：用handler.post一个runnable,这个runnable是被包装成Message对象的
• Message next：下一个可用的消息
• public static final Object sPoolSync = new Object()：sPoolSync充当锁的作用，避免多线程争抢资源
• private static Message sPool：代表消息池的头部
• private static int sPoolSize = 0：当前可用消息池个数
• private static final int MAX_POOL_SIZE = 50：最大消息池个数

Message的几个方法

Message#obtain()

Message msg = Message.obtain();这个方法是我们常用的看下它的源码

public static Message obtain() {
    synchronized (sPoolSync) {
        //Message中没有说明这个sPool是什么时候初始化的
        if (sPool != null) {
            Message m = sPool;//m指向消息头 可以把它当作一个栈的结构
            sPool = m.next;//sPool从栈顶向下移动一个单位
            m.next = null;//栈顶的元素出栈
            m.flags = 0; // 设置m此时不可用
            sPoolSize--;//消息池中可用的Message个数减一
            return m;//将栈顶的Message返回
        }
    }
    return new Message();
}

Message可以通过new Message()来获取一个Message对象，但是最好的方式是调用Message.obtain()来获取。因为当它被回收的时会被放入一个对象池中。所以obtain方法中当消息池中没有Message的时候会new Message(),否则就会从消息池中取出一个可用的Message对象。具体的流程在注释中标出，Message消息池其实是一个链表结构，但是实现的过程可以认为是一个栈，取出一个Message其实就是一个弹栈的过程。

Message#recycleUnchecked

既然有从消息池取出Message的过程，那么就有Message被回收的过程，这个过程就在recycleUnchecked方法中

public void recycle() {
    if (isInUse()) {
        if (gCheckRecycle) {
            throw new IllegalStateException("This message cannot be recycled because it "
                    + "is still in use.");
        }
        return;
    }
    recycleUnchecked();
}

recycleUnchecked方法是在recycle方法中被调用的。
recycle方法通过isInUse()方法判断flag是否可用来执行回收方法。

void recycleUnchecked() {
    //将flag标志位设置为可用状态
    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) {
        //判断当前的sPoolSize可复用的Message个数是否小于最大Message个数(50个)
        if (sPoolSize < MAX_POOL_SIZE) {
            //执行入栈操作 复用池Message个数加一
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

回收可能正在使用的消息。在处理排队的消息时由MessageQueue和Looper内部使用。

Message#sendToTarget

public void sendToTarget() {
    target.sendMessage(this);
}

在发送消息的时候我们也可以使用sendToTarget方法，只不过这个方法是Message对象调用的。它的内部实现了handler.sendMessage(msg)方法。

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

target就是handler

Message存储数据的方式

public final class Message implements Parcelable

Message对象实现了Parcelable接口，说明Message内部运用了序列化的方法。

public static final Parcelable.Creator<Message> CREATOR
        = new Parcelable.Creator<Message>() {
    public Message createFromParcel(Parcel source) {
        Message msg = Message.obtain();
        //读取Parcel中的数据
        msg.readFromParcel(source);
        return msg;
    }

    public Message[] newArray(int size) {
        return new Message[size];
    }
};

public int describeContents() {
    return 0;
}

//将数据写入Parcel
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();
}

总结

1. Message作为消息实体可以通过what、arg、obj、Bundle等携带想要发送的数据
2. Message内部维护一个消息池，这个消息池的最大容量MAX_POOL_SIZE是50。存储Message的结构是一个链表，obtain方法获得的Message对象就是当前链表的第一个Message。可以把这个链表操作的方法想成一个栈的结构。
3. Message.obtain方法和Handler.obtainMessage方法等价。

这是我第一次自己完全分析的一篇源码，之前分析源码或多或少都有参考。有什么不足的地方还请大家指正。加油！！！