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界面的方法。

 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。