文档章节

Android异步消息处理机制Handler

枫TI
 枫TI
发布于 2016/12/30 14:31
字数 1120
阅读 11
收藏 0

简单来说就是在线程中开启无限循环,处理队列中的消息。

说明:其实不应该描述为队列。队列:先进先出。从如下源代码中看出,是一个单项链表。

MessageQueue最终类,不可被继承。

构造函数默认修饰符,只能在本包中实例化MessageQueue对象。

MessageQueue.java
{    
    boolean enqueueMessage(Message msg, long when) {       
       Message p = mMessages;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }
    }
}

问题一:无限循环?那会抛出异常的?没错,解决办法就是MessageQueue中没有Message对象时休眠。

问题二:如何休眠呢?

问题三:又是如何唤醒线程的呢?

无限循环追根溯源

汇编语言实现无限循环

fin:

    HLT

    JMP fin

C语言实现无限循环

fin:

    /**这里想写HLT,但是C语言不能使用HLT*/

    goto fin;    //这里是是有分号的

Android/Java实现无限循环

for( ; ; ) {



}

1.线程中开启无限循环

Looper.java

Looper.java
{
    public static void loop() {
        for(;;){
            Message msg = queue.next();//可能会阻塞
            if (msg == null) {
                return;//退出函数
            }
        }

    }
}

 

2.消息队列(MessageQueue)push Message对象

MessageQueue.java
{

    synchronized (this) {
        //Try to retrieve the next message.  Return if found.(试图获取下一条消息,如果有则返回)
        Message next() {
            //Handler target
            if (msg != null && msg.target == null) {
            // Stalled by a barrier.  Find the next asynchronous message in the queue.
            do {
                prevMsg = msg;
                msg = msg.next;
            } while (msg != null && !msg.isAsynchronous());//
        }
    }
}

Message.java
{
    int flags;
    //<<位运算符,左移,左边的数值想左移动一位。
    //这里就是0001移动一位后变成0010
    static final int FLAG_ASYNCHRONOUS = 1 << 1;
    public boolean isAsynchronous() {
        //&位运算符,位与,位相同结果位1。
        //flag & 0010
        return (flags & FLAG_ASYNCHRONOUS) != 0;
    }
}

2.1.判断处理Message对象的的时间

MessageQueue.java
{
    Message next() {
        final long now = SystemClock.uptimeMillis();
        synchronized(this) {
            if (msg != null) {
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    //下一条消息对象还没准备好,设置一定的时间让准备
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);                   
                }
            }
        }  
    }
}

Message.java
{
    long when;
    /***/
    void recycleUnchecked() {
       when = 0;
    }
    /**回收*/
    public void recycle() {
        recycleUnchecked();
    }

    
    public long getWhen() {
        return when;
    }


}

2.2.MessageQueue队列如何组织Message对象的

Message.java
{   //以链表的形式存储Message对象
    Message next;

    private static Message sPool;

    private static int sPoolSize = 0;

    private static final int MAX_POOL_SIZE = 50;

    /**
     *返回一个新的消息实例从全球池。在许多情况下,避免分配新对象。
     */
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

    //<6>
    public void recycle() {
        if (isInUse()) {
            if (gCheckRecycle) {
                throw new IllegalStateException("This message cannot be recycled because it "
                        + "is still in use.");
            }
            return;
        }
        recycleUnchecked();
    }

    //<7>
    void recycleUnchecked() {
        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
}

MessageQueue.java
{
    /**
     *
     *
     *<5>线程中调用到这个函数时是重点!重点!重点!
     *
     */
    boolean enqueueMessage(Message msg, long when) {
        //同步,在一个线程中
        synchronized (this) {
            if (mQuitting) {
                msg.recycle();
            }

        }
    }
}

Handler.java
{
    //<1>
    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

    //<2>
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

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

    //<4>
    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
}

3.阻塞线程

MessageQueue.java

MessageQueue.java
{
    Message next() {
        for(;;) {
            //刷新等待命令,猜测这里实现的就是线程阻塞,也是一个本地方法
            //查看注释:可能会阻止很长一段时间。
            Binder.flushPendingCommands()
            //这里调用了一个本地方法,方法名称上看--本地检测一次,检测什么呢?
            nativePollOnce(ptr, nextPollTimeoutMillis);
        }
    }
}

看到调用本地方法,是不是有种山穷水尽的嗡嗡感觉。其实看看上面描述的c语言无限循环代码大致就了解库中无非也就是这么实现的。

队列中有Message对象,但是处理该对象的时间未到,计算阻塞的时间。

MessageQueue.java
{
    Message next() {
        for(;;) {
            //nextPollTimeoutMillis阻塞时间
            nativePollOnce(ptr, nextPollTimeoutMillis);
            if (msg != null) {
                if (now < msg.when) {
                    // 计算线程阻塞时间
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                }
            }
        }
    }
}

队列中没有Message对象,则无限期的阻塞直到有Message对象插入队列中时唤醒线程。

MessageQueue.java
{
    Message next() {
        for(;;) {
            //nextPollTimeoutMillis休眠时间
            nativePollOnce(ptr, nextPollTimeoutMillis);
            synchronized (this) {
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
            
            }
            if (msg != null) {
            
            } else {
                // No more messages.
                //-1代表无限期的休眠
                nextPollTimeoutMillis = -1;  
            }
        }
    }

    boolean enqueueMessage(Message msg, long when) {
        synchronized (this) {
            boolean needWake;
            if (needWake) {
                //唤醒线程
                nativeWake(mPtr);
            }
           

        }
    }

}

 

获取Message对象的代码写的非常好可以阅读学习学习

ActivityThread.java

    public static void main(String[] args) {

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

 

© 著作权归作者所有

枫TI
粉丝 14
博文 86
码字总数 43215
作品 2
东城
私信 提问
android消息机制,异步和多线程

android消息机制,异步和多线程 前言 在xxxx1.92正式版的时候付费购买曾单独封装了一个流程PaymentFlow并继承于Handler,调用方只要依据这个流程创建流程实例并触发开始,实例即可依据设定的支付...

ZHL
2012/09/03
0
0
Android:用Handler实现异步处理功能

一.一个问题 有这样一个问题值得我们思考,若把一些类似于下载的功能(既耗时且不一定有结果)写在Activity(主线程)里,会导致Activity阻塞,长时间无响应,直至页面假死(如果5秒钟还没有完成...

z.net
2012/08/15
0
0
拨云见日---android异步消息机制源码分析(一)

做过windows GUI的同学应该清楚,一般的GUI操作都是基于消息机制的,应用程序维护一个消息队列,开发人员编写对应事件的回调函数就能实现我们想要的操作 其实android系统也和windows GUI一样...

JohnnyR
2015/02/13
0
0
Android 异步加载解决方案

Android的Lazy Load主要体现在网络数据(图片)异步加载、数据库查询、复杂业务逻辑处理以及费时任务操作导致的异步处理等方面。在介绍Android开发过程中,异步处理这个常见的技术问题之前,...

Pandora
2012/08/14
0
1
android的消息处理机制(图+源码分析)——Looper,Handler,Message

作为一个大三的预备程序员,我学习android的一大乐趣是可以通过源码学习google大牛们的设计思想。android源码中包含了大量的设计模式,除此以外,android sdk还精心为我们设计了各种helper类...

火蚁
2014/05/14
0
0

没有更多内容

加载失败,请刷新页面

加载更多

GitLab Auto DevOps功能与Kubernetes集成教程

介 绍 在这篇文章中,我们将介绍如何将GitLab的Auto DevOps功能与Rancher管理的Kubernetes集群连接起来,利用Rancher v2.2.0中引入的授权集群端点的功能。通过本文,你将能全面了解GitLab如何...

RancherLabs
14分钟前
3
0
基本类型 引用类型的问题

用concat()拷贝了个数组 ,原数组包含了引用类型, tempAee === this.dynacArr[0][this.dynacArr[1]][0] //false 虽然拷贝了个数组 , tempAee[0] === this.dynacArr[0][this.dynacArr[1]][......

东东笔记
15分钟前
1
0
Linux下Java运行.class文件,报错找不到或无法加载主类

Linux下Java运行.class文件,报错找不到或无法加载主类 classpath配置的错误,所以找不到.class文件。 原先的etc/profile中的classpath配置 export CLASSPATH=$JAVA_HOME/lib/tools.jar 更改...

Mr_Tea伯奕
26分钟前
1
0
vue 日期计算

搞开发少不了对时间进行加减操作,尤其是前端对日期操作不能单纯的加减,不然31+1 变成32号就扯了。比如推算前几分钟、后几分钟,,前几天、后几天,前几月、后几月等等相关操作。 百度找半天...

朝如青丝暮成雪
38分钟前
1
0
非递归实现后序遍历二叉树

问题描述 从键盘接受输入先序序列,以二叉链表作为存储结构,建立二叉树(以先序来建立)并对其进行后序遍历,然后将遍历结果打印输出。要求采用非递归方法实现。 解题思路 Push根结点到第一...

niithub
51分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部