教你手写Java层handler机制

handler消息框架

1.Looper是消息循环类，负责从消息队列取消息，然后通过handler转发给UI线程，它包含mQueue成员变量，mQueue是一个消息队列MessageQueue。

2.MessageQueue是消息队列类，它包含了mMessages成员；mMessages是消息Message的实例。MessageQueue提供了next()方法来获取消息队列的下一则消息。

3.Message是一个消息结构体。包含next，next是一个Message实例，可以看出Message其实是一个链表。包含target成员，target是Handler实例。此外，它还包括了arg1,arg2,what,obj等参数，它们都是用于记录消息的相关内容。

4.Handler是消息句柄类。Handler提供了sendMessage()来向消息队列发送消息； 此外，Handler还提供了handleMessage()来由子类处理消息队列的消息；这样，用户通过覆盖handleMessage()就能处理相应的消息。
消息机制位于Java层的框架主要就有上面4个类所组成。在C++层，比较重要的是NativeMessageQueue和Loop这两个类。

模拟handler消息机制

1.编写Message类：
这类为了简便，很多方法不去实现，只是简单的模拟通信机制，具体细节可以取查看官方handler源码。

public class Message {

    public int what;

    public int arg1;


    public int arg2;

    public Object obj;

    public Handler target;

    @Override
    public String toString() {
    //这类只模拟String类型数据，为了方便日志输出
        return obj.toString();
    }
}

只是一个简单的javaBean，没有实现单链表，没什么好解释的。

MessageQueue类：

public class MessageQueue {
    private static final String TAG = MessageQueue.class.getName();
    Message[] mItems;


    public MessageQueue() {
        mItems = new Message[50];
    }

    /**
     * 消息队列取消息 出队
     *
     * @return
     */
    Message next() {
        return null;
    }

    /**
     * 添加消息进队列
     *
     * @param message
     */

    public void enqueueMessage(Message message) {
    }
}

这类MessageQueue内部使用数组来模拟消息队列，定义一个mItems数组存放消息，源码使用的是链表。两个重要的方法：入队enqueueMessage()；出队 next()。

Looper类：

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<>();
    public MessageQueue mQueue;

    public Looper() {
        mQueue = new MessageQueue();
    }

    /**
     * 实例化一个属于当前线程的looper对象
     */
    public static void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

    public static Looper myLooper() {
        return sThreadLocal.get();
    }

    /**
     * 轮询消息队列
     */
    public static void loop() {
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        //轮询
        Message msg;
        for (; ; ) {
            msg = queue.next();
            //获取到发送消息的 msg.target （handler）本身，然后分发消息
            if (msg == null || msg.target == null) {
                continue;
            }

            msg.target.dispatchMessage(msg);

        }
    }

mQueue:消息的队列，在Looper初始化的时候创建这个队列，在loop方法中不断的从队列中取消息，然后把消交给handler

queue.next();
......
msg.target.dispatchMessage(msg)

prepare方法。给ThreadLoacl设置Looper值，这样保证每个现场访问的Looper都是私有的Looper备份

  sThreadLocal.set(new Looper());

myLooper方法。从sThreadLocal中取得私有的Looper变量

loop方法。 轮询消息队列

Handler类：

public class Handler {
    private Looper mLooper;
    private MessageQueue mQueue;

    public Handler() {
        mLooper = Looper.myLooper();
        mQueue = mLooper.mQueue;
    }

    public void sendMessage(Message message) {
        message.target = this;
        mQueue.enqueueMessage(message);
    }

    /**
     * 子类处理消息
     *
     * @param message
     */
    public void handleMessage(Message message) {

    }

    /**
     * 分发消息
     *
     * @param message
     */
    public void dispatchMessage(Message message) {
        handleMessage(message);
    }
}

handler也很简单，持有Looper，MessageQuene，通过sendMessage方法不断的给MessageQuene中添加消息，同时把handler对象绑定到Message上，方便消息处理完成后分发消息。
dispatchMessage方法分发消息，调用了handleMessage方法，这个方法大家都很熟悉，没有实现，交给子类重写，在这里处理消息。

整个handler处理流程都写完了，来看看整个流程的时序图（懒的画，网上找了张，感谢【hnust_癫狂】共享）

首先生成Message，丢给Handler，通过sendMessage()方法将Message发送到消息队列MessageQueue中去;还有一点需要说明的是,轮询器Looper是一直在轮询状态的,一直对消息队列MessageQueue进行轮询,如果一旦发现有Message,将Message返回;然后通过Message中Target拿到Handler对象,进行调用dispatchMessage() 将Looper拿到的message分发出去,最后Handler拿到消息,执行handlerMessage()方法。

上面遗留了一个很核心的问题—–消息队列是怎样处理这些消息的？

接下来通过生产者／消费者模型来实现消息队列，这也是handler跨线程的核心部分

要实现生产者／消费者模型，首先的有锁，这里使用ReentrantLock
主要考虑的重写入，它可以根据设定的变量来唤醒不同类型的锁，也就是说当我们队列有数据时，我们需要唤醒read锁；当队列有空间时，我们需要唤醒写锁。

public class MessageQueue {
    private static final String TAG = MessageQueue.class.getName();
    Message[] mItems;
    int mPutIndex;
    //队列中消息数
    private int mCount;
    private int mTakeIndex;
    //锁
    Lock mLock;
    //条件变量
    Condition mNotEmpty;//可取
    Condition mNotFull;//可添加

    public MessageQueue() {
        mItems = new Message[50];
        mLock = new ReentrantLock();
        mNotEmpty = mLock.newCondition();
        mNotFull = mLock.newCondition();
    }

    /**
     * 消息队列取消息 出队
     *
     * @return
     */
    Message next() {
        Message msg = null;
        try {
            mLock.lock();
            //检查队列是否空了
            while (mCount <= 0) {
                //阻塞
                mNotEmpty.await();
                Log.i(TAG, "队列空了，读锁阻塞");
            }
            msg = mItems[mTakeIndex];//可能空
            //消息被处理后，置空数组中该项
            mItems[mTakeIndex] = null;
            //处理越界，index大于数组容量时，取第一个item
            mTakeIndex = (++mTakeIndex >= mItems.length) ? 0 : mTakeIndex;
            mCount--;
            //通知生产者生产
            mNotFull.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            mLock.unlock();
        }

        return msg;
    }

    /**
     * 添加消息进队列
     *
     * @param message
     */

    public void enqueueMessage(Message message) {

        try {
            mLock.lock();
            //检查队列是否满了
            while (mCount >= mItems.length) {
                //阻塞
                mNotFull.await();
                Log.i(TAG, "队列满了，写锁阻塞");
            }

            mItems[mPutIndex] = message;
            //处理越界，index大于数组容量时，替换第一个item
            mPutIndex = (++mPutIndex >= mItems.length) ? 0 : mPutIndex;
            mCount++;
            //通知消费者消费
            mNotEmpty.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            mLock.unlock();
        }


    }
}

自己手写一次handler消息处理机制，再回过头来看看handler是不是很简单了，再也不怕面试中被问到。当然android源码中的handler处理机制移值到C层处理了，我们不管它在c层还是java层，原理都是一致的，有兴趣可以去翻翻c层的源码。

实例代码下载：https://github.com/honjane/handlerDemo