zoukankan      html  css  js  c++  java
  • Android Handler机制(四)---Handler源码解析

    Handler的主要用途有两个:(1)、在将来的某个时刻执行消息或一个runnable,(2)把消息发送到消息队列。

       主要依靠post(Runnable)、postAtTime(Runnable, long)、postDelayed(Runnable, long)、sendEmptyMessage(int)、sendMessage(Message)、sendMessageAtTime(Message)、sendMessageDelayed(Message, long)这些方法来来完成消息调度。post方法是当到Runable对象到达就被插入到消息队列;sendMessage方法允许你把一个包含有信息的Message插入队列,而且它会Handler的handlerMessage(Message)方法中执行(该方法要求在Handler的子类中实现)。

    1.构造方法

     /**   默认的构造方法,handler是和当前线程的队列关联在一起,如果队列不存在,那么handler就不能接受消息。
         * Default constructor associates this handler with the {@link Looper} for the
         * current thread.
         * 如果线程没有looper,就会抛出异常
         * If this thread does not have a looper, this handler won't be able to receive messages
         * so an exception is thrown.
         */
    public Handler() {
            this(null, false);
        }
    //传入一个callback接口用于处理handler传递的Message。
     public Handler(Callback callback) {
            this(callback, false);
        }
    
    //给变量赋值  
    public Handler(Callback callback, boolean async) {
            if (FIND_POTENTIAL_LEAKS) {
                final Class<? extends Handler> klass = getClass();
                if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                        (klass.getModifiers() & Modifier.STATIC) == 0) {
                    Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                        klass.getCanonicalName());
                }
            }
    
            mLooper = Looper.myLooper();
            if (mLooper == null) {
                throw new RuntimeException(
                    "Can't create handler inside thread that has not called Looper.prepare()");
            }
            mQueue = mLooper.mQueue;
            mCallback = callback;
            mAsynchronous = async;
        }
        
    public Handler(Looper looper, Callback callback, boolean async) {
            mLooper = looper;
            mQueue = looper.mQueue;
            mCallback = callback;
            mAsynchronous = async;
        }
    

      方法都差不多,主要是完成了赋值的过程,还有几个没粘贴,但是都差不多。。。

    2.变量

    /*
         设置这个标记为true来检测不是静态的匿名,本地或成员类继承Handler类。这些类型的类可以带来潜在的泄漏。在Handler的构造方法里面使用到了这个参数,目的就如上所述。
         */
        private static final boolean FIND_POTENTIAL_LEAKS = false;
        final MessageQueue mQueue;
        final Looper mLooper;
        final Callback mCallback;  //回调接口
        final boolean mAsynchronous;
        IMessenger mMessenger;
    

      接着下面就是Callback接口:

     /**
         * Callback interface you can use when instantiating(实例化) a Handler to avoid
         * having to implement(实现) your own subclass of Handler.
         * @param msg A {@link android.os.Message Message} object
         * @return True if no further handling is desired
         */
        public interface Callback {
            public boolean handleMessage(Message msg);
        }

    callback接口你可以在实例化的时候用,避免去实现你自己的handler子类

    这个Callback接口里只有一个handleMessage方法返回boolean值,在后面Handler的ctor会用到,一般情况下都是null。这个接口的存在

    没什么特殊的含义,只是为了让你不extends Handler就能处理消息而已(正如此方法的doc所说),类似Thread和Runnable接口的关系。

    3.handleMessage

    /**
         * Subclasses must implement this to receive messages.
         */
        public void handleMessage(Message msg) {
        }

    子类需要实现这个方法,因为这是个空方法。

    4.dispatchMessage​

    /**
         * Handle system messages here.
         */
        public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                handleMessage(msg);
            }
        }
    private static void handleCallback(Message message) {
            message.callback.run();
        }

    它的处理是如果message自身设置了callback,则

    直接调用callback.run()方法,否则Callback接口的作用就显现了;如果我们传递了Callback接口的实现,即mCallback非空,则调用它处理

    message,如果处理了,返回true,则直接返回,否则接着调用Handler自己的handleMessage方法,其默认实现是do nothing,如果你

    是extends Handler,那么你应该在你的子类中为handleMessage提供自己的实现。

    5.一系列obtainMessage

    public final Message obtainMessage()
        {
            return Message.obtain(this);
        }
    public final Message obtainMessage(int what)
        {
            return Message.obtain(this, what);
        }
    public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
        {
            return Message.obtain(this, what, arg1, arg2, obj);
        }

    从上面可以看出来还是调用的Message的obtain方法,来构造message。

    6.一系列postXXX方法:

     /**
         * Causes the Runnable r to be added to the message queue.
         * The runnable will be run on the thread to which this handler is 
         * attached. 
         *  
         * @param r The Runnable that will be executed.
         * 
         * @return Returns true if the Runnable was successfully placed in to the 
         *         message queue.  Returns false on failure, usually because the
         *         looper processing the message queue is exiting.
         */
     public final boolean post(Runnable r)
        {
           return  sendMessageDelayed(getPostMessage(r), 0);
        }
    public final boolean postAtTime(Runnable r, long uptimeMillis)
        {
            return sendMessageAtTime(getPostMessage(r), uptimeMillis);
        } 
    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
        {
            return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
        }
    public final boolean postDelayed(Runnable r, long delayMillis)
        {
            return sendMessageDelayed(getPostMessage(r), delayMillis);
        }
     public final boolean postAtFrontOfQueue(Runnable r)
        {
            return sendMessageAtFrontOfQueue(getPostMessage(r));
        }

    上面方法的作用就是:把Runnable发送到消息队列,执行的时候实行Runnable的run方法。。

    下面看一系列sendXXX方法,和上边对应的。。。

    //把消息入队
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
        {
            if (delayMillis < 0) {
                delayMillis = 0;
            }
            return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
        }
    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
            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, uptimeMillis);
        }
     public final boolean sendEmptyMessage(int what)
        {
            return sendEmptyMessageDelayed(what, 0);
    

      上面所有的postXXX,sendXXX方法最后都会调用这个方法:enqueueMessage

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

     最后调用queue的enqueueMessage方法把msg入队,对这个方法不了解的,可以看前边的MessageQueue源码解析。

    SystemClock.uptimeMillis(),就是表示系统开机到当前的时间总数,如果有延迟,就加上延迟时间,分析到现在,我们也能发现,postDelayed不是延迟多少秒发送消息,这个消息是直接发送给队列的,不过在MessaegQueue中,消息按时间排放的,不到时间不会把它取出来,所以应该说延迟多少秒取出消息更合适。。

    至于上边的getPostMessage(r)就是把r设置给callback。

    private static Message getPostMessage(Runnable r) {
            Message m = Message.obtain();
            m.callback = r;
            return m;
        }

    removeCallbacks:

      调用MQ的removeMessages方法。就是移出messageQueue中所有满足条件的message,当然前提是消息还没取走。

      /**
         * Remove any pending posts of Runnable r that are in the message queue.
         */
        public final void removeCallbacks(Runnable r)
        {
            mQueue.removeMessages(this, r, null);
        }
        /**
         * Remove any pending posts of Runnable <var>r</var> with Object
         * <var>token</var> that are in the message queue.  If <var>token</var> is null,
         * all callbacks will be removed.
         */
        public final void removeCallbacks(Runnable r, Object token)
        {
            mQueue.removeMessages(this, r, token);
        }
    

       分析结束,鼓励自己下。。哈哈哈。。。。

    前三篇传送门: Looper源码解析: http://www.cnblogs.com/jycboy/p/5787443.html

                        MessageQueue源码解析: http://www.cnblogs.com/jycboy/p/5786682.html

                        Message源码解析:http://www.cnblogs.com/jycboy/p/5786551.html

  • 相关阅读:
    DevExpress ASP.NET v19.1版本亮点:Pivot Grid等控件
    .NET界面控件DevExpress全新发布v19.1.5|改进Office 2019主题
    Kendo UI for jQuery使用教程:操作系统/jQuery支持等
    Web安全篇之SQL注入攻击
    SQL Server中timestamp(时间戳)和rowversion(版本戳)
    PyCharm2019 激活码
    性能测试 vs 负载测试 vs 压力测试
    一套完整的压力测试项目文档
    Visual Studio性能计数器,负载测试结果分析- Part III
    Visual Studio进行负载测试,RIG和负载测试术语- Part II
  • 原文地址:https://www.cnblogs.com/jycboy/p/5791457.html
Copyright © 2011-2022 走看看