android 的消息处理

算是工作记录吧。。。

首先，android中界面的更新都必须放到主线程中间去做，当我们在子线程中想要更新界面的时候，可以通过Handler和Message这两个类来进行处理。比如新开了一个线程，用来进行下载任务，通过Handler显示进度条等。大概的过程是这样的，首先获得一个message ,然后调用sendMessage发送出去，然后就可以在重写的handler类的函数里面进行处理了。

new Thread() {            public void run() {                    ...                Message msg = Message.obtain();                ...                msg.what = NETWORK_ERROR; 
　　　　　　　　　... 
　　　　　　　　　handler.sendMessage(msg); 
　　　　　　　　} 
}.start();

private Handler handler = new Handler() {        public void handleMessage(android.os.Message msg) {            switch (msg.what) {            case NETWORK_ERROR:                ...                break;            }        };    };

我们可以点进去看看Handler和Message的源码，会发现内部还会涉及到两个类，Looper和MessageQueue。

先看Message，

public final class Message implements Parcelable {    public int what;    public int arg1;     public int arg2;    public Object obj;    public Messenger replyTo;    /*package*/ int flags;    /*package*/ long when;        /*package*/ Bundle data;        /*package*/ Handler target;             /*package*/ Runnable callback;           /*package*/ Message next;    ...}

然后首先的问题是，为什么不直接Message msg = new Message(),而是用Message.obtain() ;这点在注释里已经有说明了：

    /**     * 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();    }　public static Message obtain(Handler h, Runnable callback)；　public static Message obtain(Handler h, int what)
　　...

这里采用类似于线程池的方法，是从global pool里面取出来消息，当global pool中的消息全部被用光了，才会new Message()，避免频繁申请和释放资源带来的性能损耗。这个类下面也写了很多个不同参数的重载方法。另外一种获得Message的方法是Handler.obtainMessage()，看源码可以知道也是调用的Message.obtain();

然后是发送消息的方式，handler.sendMessage ：

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

这里的target在上面可以看到，是Message的一个Handler类型的成员，表示接收这个消息的handler对象。而Handler类里面的sendMessage方法，一路跟下去可以看到，最后执行的是调用Handler类的MessageQueue类型的成员对象mQueue的enqueueMessage方法。

   public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }         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);    }    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }

因此sendMessage ，实际上是发送到Message对象的handler成员的MessageQueue队列里面去了。然后的问题是消息是怎么取出来的?先看Handler类：

public class Handler {    final MessageQueue mQueue;    final Looper mLooper;    final Callback mCallback;    final boolean mAsynchronous;    IMessenger mMessenger;        /**     * Default constructor associates this handler with the {@link Looper} for the     * current thread.     *     * If this thread does not have a looper, this handler won't be able to receive messages     * so an exception is thrown.     */    public Handler() {        this(null, false);    }          public Handler(Callback callback, boolean async) {        ...        mLooper = Looper.myLooper();        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;        mCallback = callback;        mAsynchronous = async;    }   
　　...   }

可以看到，handler创建的时候没有指定Looper的话，是会默认绑定到当前的线程中去的。当我们在Activity中直接new Handler的时候，就绑定到主线程上面去了。

因此整个过程是，当android程序启动的时候，主线程就会启动了，然后启动主线程的消息循环，也就是Looper.loop()，因此默认new Handler出来的对象，都会把消息发送到主线程的MessageQueue中去。子线程创建的时候不会默认启动消息循环，想要进行消息处理，必须主动去启动消息循环，生成自己的消息队列。Looper中的loop方法：

 public static void loop() {        final Looper me = myLooper();    ...        final MessageQueue queue = me.mQueue;        for (;;) {            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            msg.target.dispatchMessage(msg);            ...            msg.recycle();        }

调用了loop方法以后，就开始执行分发和回收消息的动作了，Handler.dispatchMessage:

    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }

首先检查Message的Runnable接口是否为空，然后检查handler的callback是否为空,如果都是空，进入到Handler的handlerMessage方法，因为多态的原因，最终会跳转到我们重写的handlerMessage()方法里面去！

看完之后的感想：既然每一个消息都有一个handler对象作为target,而我们可以把很多handler都绑定到主线程的消息队列里面去，因此只要获得了界面A的handler，那么就可以给界面A发送消息，进入界面A的消息处理函数里面去！是不是有点类似于windows窗口的句柄呢,:-)，这也是我在后面JNI调用的时候所使用的通知android界面的方法。

更多相关文章

随机推荐