用Java实现一个类似AndroidHandler的消息循环

Android的Handler是Android应用层App运行的核心，App除了InputEventReceiver外，其他的代码运行，比如生命周期，UI绘制都是被封装成了Message消息的形式被Looper循环处理的。消息循环的休眠唤醒是依赖linux的epoll机制实现的。最终效果就是app在有任务的时候被唤醒执行任务，没有任务的时候就休眠，App不会在没有任务的时候空转CPU消耗资源。

上面的不明白的可以参考下其他文章。

好，现在明白了Handler的整个原理，那如果让我们自己来实现一个类似Android的Handler的框架结构，应该怎么实现呢？
首先一定会有一个数据结构来存储所有需要处理的消息，然后每处理一个消息就把消息从队列移除。所以这里需要用队列。定义一个Queue。

private final Queue<Runnable> mQueue = new LinkedList<>();

private void addRunnable(Runnable runnable) {
    mQueue.add(runnable);
}

public Runnable getRunnable(){
    if (!mQueue.isEmpty()) {
        return mQueue.poll();
    }
    return null;
}

然后会有一个执行代码的线程，肯定会有一个死循环不断从queue里拿Runnable出来。然后运行runnable。

while (true) {
    Runnable runnable = getRunnable();
    if (runnable != null) {
        runnable.run();
    }
}

再梳理下思路。Queue保存所有需要处理的任务，我们这里任务先用Runnable表示。可以在任意一个线程调用Queue的add方法来添加Runnable。然后另外有个线程里是下面这个while(true)，不断从Queue里取runable来执行。
好，这里突然发现，添加runnable和运行runnable涉及到跨线程了。所以这里需要处理下线程安全问题。所以把代码改造成下面这样。

private static final Queue<Runnable> mQueue = new LinkedList<>();

private static void addRunnable(Runnable runnable) {
    synchronized (mQueue) {
        mQueue.add(runnable);
    }
}

private static Runnable getRunnable() {
    synchronized (mQueue) {
        if (!mQueue.isEmpty()) {
            return mQueue.poll();
        }
    }
    return null;
}

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("创建Runnable的线程id = " + Thread.currentThread().getId());
            addRunnable(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行Runnable的线程id = " + Thread.currentThread().getId());
            }
        });
        }
     }).start();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    while (true) {
        Runnable runnable = getRunnable();
        if (runnable != null) {
            runnable.run();
        }
     }
}

运行上面的代码控制台会打印：

创建Runnable的线程id = 11
执行Runnable的线程id = 1

添加了线程同步，这里不会因为跨线程导致的数据同步问题了。再梳理下思路，线程11向queue addRunnable，这时候假如有个其他线程正在add或者get，也不要紧，synchronized会自动帮我们处理线程同步，保证add一定不会和其他线程发生冲突。不会导致add丢失。这时候add操作是在线程1完成的。然后线程1无限getRunnable，拿到后run执行runnable。
这么想似乎勉强实现了消息队列，也实现了runnable在其他线程创建，然后被线程1执行。
但是一运行就会发现一个严重的问题。因为线程1是个while(true)，而且循环体内没有任何线程休眠，这会导致线程1，即使在没有runnable需要执行的时候，依然在不断从queue里取数据出来，不断的取，无限消耗CPU资源。这肯定是不行的。硬件资源都给这哥们用来空跑了。
那我们有没有什么办法能让线程1智能一点，让线程1能在没有runnable的时候线程休眠不消耗CPU，然后等有任务来了，再唤醒去执行任务，让CPU资源只用来处理任务，而不是空转？
关键点来了，怎么让线程1知道自己什么时候休眠什么时候唤醒呢？Android里这里利用的是Linux的epoll机制来实现的。效果就是线程1没有任务了就休眠不消耗资源，任务来了，被唤醒去执行任务。
Java里Object有两个方法final native方法wait和notifyAll，如果用过，熟悉这两个方法的话，这里就有思路了。当线程1没有任务的时候进入wait不再消耗cpu，然后其他任意线程addRunnable的时候notifyAll唤醒线程1，然后线程1唤醒执行runnable，然后再runnable执行完成之后再次进入wait状态。
我们把上面代码改造成下面这样：

private static final Queue<Runnable> mQueue = new LinkedList<>();

private static void addRunnable(Runnable runnable) {
    synchronized (mQueue) {
        mQueue.notifyAll();
        mQueue.add(runnable);
    }
}

private static Runnable getRunnable() {
    synchronized (mQueue) {
        if (!mQueue.isEmpty()) {
            return mQueue.poll();
        } else {
            try {
                mQueue.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    return null;
}

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("创建Runnable的线程id = " + Thread.currentThread().getId());
            addRunnable(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行Runnable的线程id = " + Thread.currentThread().getId());
                }
            });
            }
        }).start();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    int index = 0;
    while (true) {
        System.out.println("第" + (++index) + "次循环");
        Runnable runnable = getRunnable();
        if (runnable != null) {
            runnable.run();
        }
    }
}

运行结果：

创建Runnable的线程id = 11
第1次循环
执行Runnable的线程id = 1
第2次循环

循环第一次执行任务，循环第二次就挂起等待新任务到来。到这里基本上Handler的基础东西都有了。剩下的我们可以仿造AndroidHandler的Api重新包装一个Handler-Message-Looper是非常容易的。下面的就不多解释了，可以直接参考这里的源码。
https://github.com/aesean/MessageQueue