美文网首页
用Java实现一个类似AndroidHandler的消息循环

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

作者: Jerry2015 | 来源:发表于2017-03-18 13:21 被阅读941次

    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

    相关文章

      网友评论

          本文标题:用Java实现一个类似AndroidHandler的消息循环

          本文链接:https://www.haomeiwen.com/subject/aufynttx.html