Handler机制实现原理

面试的时候经常会问handler原理啥的，前段时间刚好看了一个老师讲handle机制，老师讲得很仔细清晰，这里我自己也用代码模拟安卓handler实现一个基本线程通信。
说到handler就不得不说消息处理的五大组成部分：Message，Handler，Message Queue，Looper和ThreadLocal。首先简要的了解这些对象的概念；

Message：message就是一个数据模型吧，它的作用仅限于线程之间通信的时候传递消息，他可以携带少量数据，用于线程之间传递信息，常用的四个字段target，what，obj，arg;

target:消息回调后的作用域类，通常是一个handler。
what:是一个区分不同消息的标识符。
obj：这是obj是一个对象类型，可以携带自定义的类。
arg：int类型，携带的参数。
下面贴出Message代码：

public class Message {
    Handler target;
    public int what;
    public Object obj;

    @Override
    public String toString() {
        return obj.toString();
    }
}

handler:它主要用于发送和接收消息，有三个主要方法，这里实现基本功能，不探讨具体细节

sendMessage（）；
dispatchMessage（）；
handleMessage（）；

它主要用于发送和处理消息的发送消息一般使用sendMessage（）方法,还有其他的一系列sendXXX的方法，但最终都是调用了sendMessageAtTime方法,把消息压入消息队列中。
而发出的消息经过一系列的辗转处理后，最终会传递到Handler的handleMessage方法中。这里我们handleMessage（）方法在外部重写，内部实现调用。

public class Handler {

    private MessageQueue mQueue;
    private Looper mLooper;

    // Handler的初始化在主线程中完成
    public Handler(){
        //获取主线程的looper对象
        mLooper = Looper.myLooper();
        this.mQueue = mLooper.mQueue;
    }

    // 发送消息，压入队列
    public void sendMessage(Message msg){
        msg.target = this;
        mQueue.enqueueMessage(msg);
    }

    //内部调用，外部实现
    public void handleMessage(Message msg){

    }

    // 转发
    public void dispatchMessage(Message msg){
        handleMessage(msg);
    }
}

MessageQueue是消息队列，主要存放所有handler发送过来的消息，这些消息会一直存放消息队列中，等待被处理，每一个线程只有一直MessageQueue队列。

这里实现的消息队列里面有一个入栈和出栈函数，这两个函数的关系是一个生产者和消费者的关系，我们在Looper.loop方法中通过while死循环方法不断检测生产者方法，一旦消息队列不为空，立即取出消息并处理，同时消息的总数量也相应需要改变。

public class MessageQueue {

    //通过数组的结构存储message对象
    Message[] items;

    //入队和出队元素索引位置
    int putIndex;
    int takeIndex;

    // 计数器
    int count;


    // synchronized (msg){} 代码块加锁
    // 互斥锁
    Lock lock;
    // 条件变量
    Condition notEmpty;
    Condition notFull;

    public MessageQueue(){
        this.items = new Message[50];

        this.lock = new ReentrantLock();   //这个锁和sychronize还是有些区别的，ReentrantLock 类实现了 Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似轮询锁、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。）
        this.notEmpty = lock.newCondition();
        this.notFull = lock.newCondition();
    }

    // 加入队列
    // 生产
    public void enqueueMessage(Message msg){
        System.out.println("加入队列");

        try {
            lock.lock();

            //消息队列满了，子线程停止发送消息，阻塞
            while (count == items.length){
                try {
                    notFull.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            items[putIndex] = msg;
            //循环取值
            putIndex = (++ putIndex == items.length)?0:putIndex;
            count ++;

            //生产出来新的message对象，通知主线程
            notEmpty.signalAll();

        }finally {
            lock.unlock();
        }
    }

    // 出队列
    // 消费
    public Message next(){

        //消息队列空了，子线程停止发送消息，阻塞
        Message msg = null;
        try {
            lock.lock();

            while (count == 0){
                try {
                    notEmpty.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            msg = items[takeIndex];
            items[takeIndex] = null;   //元素重置空
            takeIndex = (++takeIndex == items.length) ? 0 : takeIndex;
            count --;

            //使用列一个message对象，通知子线程，可以继续生产
            notFull.signalAll();

        }finally {
            lock.unlock();
        }

        return msg;
    }
}

Looper：每个线程通过Handler发送的消息都保存在，MessageQueue中，Looper通过调用loop（）的方法，就会进入到一个无限循环当中，然后每当发现Message Queue中存在一条消息，就会将它取出，并传递到Handler的handleMessage（）方法中。每个线程中只会有一个Looper对象。

/**
 *  一个线程对应一个looper对象，一个looper对应一个消息队列
 */

public final class Looper {

    //每一个主线程都有一个looper对象
    //Looper 对象保存在threadlocal中，保证列线程数据的隔离
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

    // 一个looper对象 对应一个消息队列
    MessageQueue mQueue;

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

    //获取当前线程的looper对象
    public static Looper myLooper(){
        return sThreadLocal.get();
    }

    //轮询消息队列
    public static void loop(){
        Looper me = myLooper();
        if (me == null){
            throw new RuntimeException("not Looper; Looper.prepare() wait call");
        }
        MessageQueue queue = me.mQueue;
        for (;;){
            Message msg = queue.next();
            if (msg == null){
                continue;
            }
            // 转发给handler
            msg.target.dispatchMessage(msg);
        }
    }
}

在Main方法中写个测试例子

    public void test(){
        //轮询器初始化
        Looper.prepare();

        // 主线程当中
        final Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                System.out.println(Thread.currentThread().getName() + ",receive:"+msg.toString());
            }
        };

        for (int i=0;i<10;i++){
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        Message msg = new Message();
                        msg.what = 1;
                        synchronized (UUID.class){
                            msg.obj = Thread.currentThread().getName()+",send message"+ UUID.randomUUID().toString();
                        }
                        System.out.println(msg);
                        handler.sendMessage(msg);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
        }

        //开启轮询
        Looper.loop();
    }

打印结果如下：

// 08-18 19:13:28.149 8051-8129/com.dcw.handler I/System.out: Thread-5,send message41e677cd-0eb0-467b-a633-36a2e9c0cdc0
// 08-18 19:13:28.149 8051-8129/com.dcw.handler I/System.out: 加入队列
// 08-18 19:13:28.149 8051-8136/com.dcw.handler I/System.out: Thread-12,send messageebd27bf8-b157-466a-bab5-8d6057334ed2
// 08-18 19:13:28.150 8051-8136/com.dcw.handler I/System.out: 加入队列
// 08-18 19:13:28.150 8051-8051/com.dcw.handler I/System.out: main,receive:Thread-5,send message41e677cd-0eb0-467b-a633-36a2e9c0cdc0
// 08-18 19:13:28.150 8051-8051/com.dcw.handler I/System.out: main,receive:Thread-12,send messageebd27bf8-b157-466a-bab5-8d6057334ed2
// 08-18 19:13:28.154 8051-8137/com.dcw.handler I/System.out: Thread-13,send message3c1ae78b-8940-4a12-bb60-815442917edc
// 08-18 19:13:28.155 8051-8137/com.dcw.handler I/System.out: 加入队列
// 08-18 19:13:28.155 8051-8051/com.dcw.handler I/System.out: main,receive:Thread-13,send message3c1ae78b-8940-4a12-bb60-815442917edc
// 08-18 19:13:28.159 8051-8134/com.dcw.handler I/System.out: Thread-10,send messagef6beb349-975c-4e17-a475-d3cc7c5bd94f
// 08-18 19:13:28.159 8051-8134/com.dcw.handler I/System.out: 加入队列
// 08-18 19:13:28.159 8051-8135/com.dcw.handler I/System.out: Thread-11,send message8d8ecf6e-3c76-4bad-b7af-dc916cb96b39
// 08-18 19:13:28.159 8051-8135/com.dcw.handler I/System.out: 加入队列
// 08-18 19:13:28.160 8051-8051/com.dcw.handler I/System.out: main,receive:Thread-10,send messagef6beb349-975c-4e17-a475-d3cc7c5bd94f
// 08-18 19:13:28.160 8051-8051/com.dcw.handler I/System.out: main,receive:Thread-11,send message8d8ecf6e-3c76-4bad-b7af-dc916cb96b39
// 08-18 19:13:29.149 8051-8130/com.dcw.handler I/System.out: Thread-6,send messagec7afaa49-e6b0-49a9

结果分析可以看到：只要子线程中一加入消息，那么looper就会轮询从massagequeue中取出消息并且通过dispatchMessage发送到主线程中取执行。我个人觉得所谓主线程，只不过比子线程中多了一个looper，我们的UI线程在只能在主线中刷新，就是应为线程的loop方法不断轮询绘制的原因，子线程之所有不能刷新UI，是因为子线程没有loop方法，如果我们把子线程中设置一个looper，那么子线程也是可以刷新绘制UI的。
以上是我个人见解，欢迎大家斧正。