Android消息机制Message消息池

这篇文章主要说下Android在实现Message类的时候使用的一个所谓的消息池的问题。

我们在使用Android的消息循环时，一般按照下面的方式使用，为了使线程具有消息循环如下：

//实现自己的Handler类，重写handlerMessage()方法

private class MyHandler extends Handler{
@Override
public void handleMessage(Message msg) {
if(msg.what==1){
textView.setText(""+msg.arg1);//获得传递过来的数据
}
super.handleMessage(msg);
}
}

在线程的run()方法里调用Looper.prepare()，实例化一个Handler对象，调用Looper.loop()使线程进入消息循环

public void run(){
Looper.prepare();
//dosomething else
handler=new MyHandler();
Looper.loop();
}

Handler对象的实例话必须在Looper.prepare()之后。

当我们要给具有消息循环的线程发送消息时，我们先要获得具有消息循环的线程的 Handler 对象（或者先获取具有消息循环的线程的Looper对象，再使用这个Looper对象构造Handler对象），构造一个Message对象，然后调用Handler对象的sendMessage方法

Message message=Message.obtain();
message.what=1;
message.arg1=count;
handler.sendMessage(message);

 

说了这么多，现在就来说下Message里的消息池问题，我们先看Message的静态成员方法 Message.obtain();

 

// sometimes we store linked lists of these things
/*package*/ Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
sPoolSize--;
return m;
}
}
return new Message();
}

在这个类中sPool代表这个消息池的头消息，sPoolSize表示消息池中可用的消息的个数即没有被使用的Message对象的个数，next表示下一个可用的消息Message对象。

可以看到obtain()方法说会从全局消息池中取消息，假设是第一次获得一个Message对象，那么sPool肯定为null，也就说第一次获取消息Message对象时是还没有消息池的，必须通过Message的构造方法获取一个Message对象的，Message的构造方法什么也没干

/** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
*/
public Message() {
}

那这就有点奇怪了，它的消息池是什么时候初始化呢？难道不是先new几个Message对象然后存着？这是我们注意到Message类的另一个成员方法recycle()，注意这个方法不是静态的.

/**
* Return a Message instance to the global pool.  You MUST NOT touch
* the Message after calling this function -- it has effectively been
* freed.
*/
public void recycle() {
clearForRecycle();

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

 

里面的clearForRecycle()方法只是把一些成员变量置为null，以便垃圾回收

/*package*/ void clearForRecycle() {
flags = 0;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
when = 0;
target = null;
callback = null;
data = null;
}

 

从这里我们就可以发现，消息池中Message的对象是通过recycle()放进去的. 但是我们自己并没有调用recycle()方法，那这个方法是在哪里调用的？看下Looper的源码就知道，在Looper的loop()方法的最后调用了Message对象msg的recycle()方法来回收这个Message对象，通过recycle()将这个Message对象的数据清空然后链接到消息池中（采用的头插法）。