Android消息机制 java常用类

消息驱动是一种进程或线程的运行模式。内部、外部的各种事件可以放到消息队列中按序处理。比如：Android的应用UI线程。

在windows的消息处理模型中，只有一个系统消息队列，这个队列是整个进程的核心，几乎所有动作都要转换成消息，放到这个队列中，消息处理在主线程完成。

也就是有多个线程发送消息，只有一个属于进程的消息队列，以及只有一个主线程处理消息队列中的消息。

Android的消息处理不一样。Android没有全局的消息队列，消息队列是和某个线程相关的。每个线程最多只有一个消息队列，消息的取出和处理也在线程中完成。

也就是有多个线程发消息，有多个消息队列在不同的线程中，分别在各自的线程中处理消息。

Windows的消息模型比较简单，但是全局的消息队列容易成为程序的瓶颈。

Looper类

looper是线程的消息循环处理器，每个线程只能有一个Looper对象，其内部有一个MessageQueue，所有消息都存放在这个队列中。新创建一个线程时，系统不会为这个线程创建Looper，需要自己创建。Android在启动时，为主线程（UI线程——创建了一个looper对象）。

我们先看一下HandlerThread线程，其就是继承了一个普通的线程，提供了一个消息队列和消息相应代码的运行环境。

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();//Looper类的实例必须通过prepare函数创建
        synchronized (this) {
            mLooper = Looper.myLooper();//通过myLooper方法获取Looper对象
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();//loop函数主要分发消息队列中的消息。
        mTid = -1;
    }
    
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

}

下面我们主要看下Looper类中的loop方法：

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;//消息队列

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        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();
        }
    }

Handler类

Handler主要负责消息的发送和处理。在一个线程中可以只用一个Hander对象处理所以消息，也可以使用多个。

构造一个Handler对象，需要两个参数，线程的Looper对象和消息处理函数，如果不指定looper，会使用当前线程的looper对象

Handler发送消息的接口如下：

    public final boolean sendMessage(Message msg)//不插队
    {
        return sendMessageDelayed(msg, 0);
    }

    public final boolean sendEmptyMessage(int what)//只有一个消息ID
    {
        return sendEmptyMessageDelayed(what, 0);
    }

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();//指定时间，只有消息ID，其实就是自己获取一个msg，再调用sendMessageAtTime
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }

    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);
    }

    public final boolean sendMessageAtFrontOfQueue(Message msg) {//非常紧急，希望尽快处理
        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, 0);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;//注意msg.target都是handler，因此在消息线程的loop函数处理消息时，msg.target.dispatchMessage会回到handler。
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

所有的发送消息接口，最后都会调用MessageQueue类中enqueueMessage函数，参数除了消息外，就是一个时间。而MessageQueue类中enqueueMessage函数只是把消息插入到消息队列中的合适位置。

我们再来看看Handler类的一些Post类型的函数：

    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    
    public final boolean postAtTime(Runnable r, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }

    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    }

    public final boolean postDelayed(Runnable r, long delayMillis)
    {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }
    
    public final boolean postAtFrontOfQueue(Runnable r)
    {
        return sendMessageAtFrontOfQueue(getPostMessage(r));
    }

也是调用的send函数，只是调用了getPostMessage函数：

    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

创建了一个message对象，并且将Runable对象赋给了callback。

下面再来看看Handler对象的dispatchMessage就知道了：

    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);//如果msg自带了callback函数
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);//最后再调用Handler的handleMessage函数
        }
    }

看看handleCallback函数就是调用了msg的回调函数:

    private static void handleCallback(Message message) {
        message.callback.run();
    }

Handler中removeMessages将消息队列中的消息去除：

    public final void removeMessages(int what, Object object) {
        mQueue.removeMessages(this, what, object);
    }

最后总结下：首先消息机制需要一个线程环境，里面需要一个Looper对象，并且在线程的run函数中调用Looper.loop()函数。函数需要一个handler来发送和处理消息。Hander要有一个Looper对象，来指定其线程，还要实现handleMessage函数。