美文网首页
Android-Looper

Android-Looper

作者: 有腹肌的豌豆Z | 来源:发表于2020-09-25 08:47 被阅读0次

    Looper简介

    Looper.loop是一个死循环,拿不到需要处理的Message就会阻塞,那在UI线程中为什么不会导致ANR?

    首先我们来看造成ANR的原因:
    1.当前的事件没有机会得到处理(即主线程正在处理前一个事件,没有及时的完成或者looper被某种原因阻塞住了)
    2.当前的事件正在处理,但没有及时完成

    我们再来看一下APP的入口ActivityThread的main方法:

    public static void main(String[] args) {
      
            ...
    
            Looper.prepareMainLooper();
    
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
    
            if (sMainThreadHandler == null) {
                sMainThreadHandler = thread.getHandler();
            }
    
            Looper.loop();
    
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }
    
    

    显而易见的,如果main方法中没有looper进行死循环,那么主线程一运行完毕就会退出,会导致直接崩溃,还玩什么!

    现在我们知道了消息循环的必要性,那为什么这个死循环不会造成ANR异常呢?

    我们知道Android 的是由事件驱动的,looper.loop() 不断地接收事件、处理事件,每一个点击触摸或者说Activity的生命周期都是运行在 Looper的控制之下,如果它停止了,应用也就停止了。只能是某一个消息或者说对消息的处理阻塞了 Looper.loop(),而不是 Looper.loop() 阻塞它,这也就是我们为什么不能在UI线程中处理耗时操作的原因。
    主线程Looper从消息队列读取消息,当读完所有消息时,主线程阻塞。子线程往消息队列发送消息,唤醒主线程,主线程被唤醒只是为了读取消息,当消息读取完毕,再次睡眠。因此loop的循环并不会对CPU性能有过多的消耗。


    Looper类注释

    /**
     * Class used to run a message loop for a thread.  Threads by default do
     * not have a message loop associated with them; to create one, call
     * {@link #prepare} in the thread that is to run the loop, and then
     * {@link #loop} to have it process messages until the loop is stopped.
     *
     * <p>Most interaction with a message loop is through the
     * {@link Handler} class.
     *
     * <p>This is a typical example of the implementation of a Looper thread,
     * using the separation of {@link #prepare} and {@link #loop} to create an
     * initial Handler to communicate with the Looper.
     *
     * <pre>
     *  class LooperThread extends Thread {
     *      public Handler mHandler;
     *
     *      public void run() {
     *          Looper.prepare();
     *
     *          mHandler = new Handler() {
     *              public void handleMessage(Message msg) {
     *                  // process incoming messages here
     *              }
     *          };
     *
     *          Looper.loop();
     *      }
     *  }</pre>
     */
    

    Looper成员变量

    public final class Looper {
     private static final String TAG = "Looper";
    
        // 静态常量,保证一个线程只有一个 Looper;
        // sThreadLocal.get() will return null unless you've called prepare().
        @UnsupportedAppUsage
        static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    
        @UnsupportedAppUsage
        private static Looper sMainLooper;  // guarded by Looper.class
        private static Observer sObserver;
    
        /**
         * 消息队列是在Looper里面创建的
         */
        @UnsupportedAppUsage
        final MessageQueue mQueue;
    
        /**
         * 当前线程
         */
        final Thread mThread;
    
        /**
         * 打印日志的
         */
        @UnsupportedAppUsage
        private Printer mLogging;
    
        private long mTraceTag;
    
        /**
         * If set, the looper will show a warning log if a message dispatch takes longer than this.
         * 如果设置该设置,如果消息分发时间超过此时间,则该循环程序将显示警告日志。
         */
        private long mSlowDispatchThresholdMs;
    
        /**
         * If set, the looper will show a warning log if a message delivery (actual delivery time -
         * post time) takes longer than this.
         * 如果设置该设置,如果消息传递(实际传递时间-post时间)花费的时间超过此时间,则循环器将显示警告日志。
         */
        private long mSlowDeliveryThresholdMs;
    
        ....
    
    }
    
    

    Looper构造函数

       private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed); // 消息队列 这样就实现了Looper和MessageQueue的关联
            mThread = Thread.currentThread();       // 当前线程 这样就实现了Thread和Looper的关联
        }
    

    Looper.prepare();

        /**
         * Initialize the current thread as a looper.
         * This gives you a chance to create handlers that then reference
         * this looper, before actually starting the loop. Be sure to call
         * {@link #loop()} after calling this method, and end it by calling
         * {@link #quit()}.
         */
        public static void prepare() {
            prepare(true);
        }
    
        private static void prepare(boolean quitAllowed) {
            //每个线程只允许执行一次该方法,第二次执行的线程的TLS已有数据,则会抛出异常。
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            //创建Looper对象,并且保存到当前线程的TLS区域。
            sThreadLocal.set(new Looper(quitAllowed));
        }
    

    初始化当前线程和Looper,这样可以在实际开始启动循环(loop())之前创建一个Handler并且关联一个looper。确保在先调用这个方法,然后调用loop()方法,并且通过调用quit()结束。

    这里面的入参boolean表示Looper是否允许退出,true就表示允许退出,对于false则表示Looper不允许退出。

    prepareMainLooper()方法

        /**
         * Initialize the current thread as a looper, marking it as an
         * application's main looper. The main looper for your application
         * is created by the Android environment, so you should never need
         * to call this function yourself.  See also: {@link #prepare()}
         */
        public static void prepareMainLooper() {
             // 设置不允许退出的Looper
            prepare(false);
            synchronized (Looper.class) {
                //将当前的Looper保存为Looper。每个线程只允许执行一次
                if (sMainLooper != null) {
                    throw new IllegalStateException("The main Looper has already been prepared.");
                }
                sMainLooper = myLooper();
            }
        }
    
    

    初始化当前当前线程的looper。并且标记为一个程序的主Looper。由Android环境来创建应用程序的主Looper。因此这个方法不能由咱们来调用。另请参阅prepare()

    • 首先 通过方法我们看到调用了prepare(false);注意这里的入参是false
    • 其次 做了sMainLooper的非空判断,如果是有值的,直接抛异常,因为这个sMainLooper必须是空,因为主线程有且只能调用一次prepareMainLooper(),如果sMainLooper有值,怎说说明prepareMainLooper()已经被调用了,而sMainLooper的赋值是由myLooper来执行,
    • 最后调用myLooper()方法来给sMainLooper进行赋值。

    myLooper()方法

        /**
         * Return the Looper object associated with the current thread.  Returns
         * null if the calling thread is not associated with a Looper.
         */
        public static @Nullable Looper myLooper() {
            return sThreadLocal.get();
        }
    
    

    这里的sThreadLocal.get()是和prepare(boolean)方法里面的sThreadLocal.set(new Looper(quitAllowed));一一对应的。而在prepareMainLooper()方法里面。

        提出一个问题,在prepareMainLooper里面调用myLooper(),那么myLooper()方法的返回有没有可能为null?
        答:第一步就是调用prepare(false);,所以说myLooper()这个方法的返回值是一定有值的。
    

    Looper.loop();

        /**
         * Run the message queue in this thread. Be sure to call
         * {@link #quit()} to end the loop.
         */
        public static void loop() {
             // 获取TLS存储的Looper对象
            final Looper me = myLooper();
            //没有Looper 对象,直接抛异常
            if (me == null) {
                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
            }
            //获取当前Looper对应的消息队列
            final MessageQueue queue = me.mQueue;
    
            // Make sure the identity of this thread is that of the local process,
            // and keep track of what that identity token actually is.
            Binder.clearCallingIdentity();
            // 确保权限检查基于本地进程,而不是基于最初调用进程
            final long ident = Binder.clearCallingIdentity();
            // 进入 loop的主循环方法
           // 一个死循环,不停的处理消息队列中的消息,消息的获取是通过MessageQueue的next()方法实现
            for (;;) {
                 // 可能会阻塞
                Message msg = queue.next(); // might block
                 // 如果没有消息,则退出循环
                if (msg == null) {
                    // No message indicates that the message queue is quitting.
                    return;
                }
    
                // This must be in a local variable, in case a UI event sets the logger
                // 默认为null,可通过setMessageLogging()方法来指定输出,用于debug功能
                Printer logging = me.mLogging;
                if (logging != null) {
                    logging.println(">>>>> Dispatching to " + msg.target + " " +
                            msg.callback + ": " + msg.what);
                }
               // 用于分发消息,调用Message的target变量(也就是Handler了)的dispatchMessage方法来处理消息
                msg.target.dispatchMessage(msg);
    
                if (logging != null) {
                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
                }
    
                // Make sure that during the course of dispatching the
                // identity of the thread wasn't corrupted.
                // 确保分发过程中identity不会损坏
                final long newIdent = Binder.clearCallingIdentity();
                if (ident != newIdent) {
                    // 打印identiy改变的log,在分发消息过程中是不希望身份被改变
                    Log.wtf(TAG, "Thread identity changed from 0x"
                            + Long.toHexString(ident) + " to 0x"
                            + Long.toHexString(newIdent) + " while dispatching to "
                            + msg.target.getClass().getName() + " "
                            + msg.callback + " what=" + msg.what);
                }
                // 将Message放入消息池
                msg.recycleUnchecked();
            }
        }
    
    
    loop进入循环模式,不断重复下面的操作,直到没有消息时退出循环
    读取MessageQueue的下一条Message
    把Message分发给相应的target
    再把分发后的Message回到消息池,以便重复利用
    

    Looper的退出循环方法

      /**
         * Quits the looper.
         * <p>
         * Causes the {@link #loop} method to terminate without processing any
         * more messages in the message queue.
         * </p><p>
         * Any attempt to post messages to the queue after the looper is asked to quit will fail.
         * For example, the {@link Handler#sendMessage(Message)} method will return false.
         * </p><p class="note">
         * Using this method may be unsafe because some messages may not be delivered
         * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
         * that all pending work is completed in an orderly manner.
         * </p>
         *
         * @see #quitSafely
         */
        public void quit() {
            mQueue.quit(false);
        }
    

    退出循环
    将终止(loop()方法)而不处理消息队列中的任何更多消息。在调用quit()后,任何尝试去发送消息都是失败的。例如Handler.sendMessage(Message)方法将返回false。因为循环终止之后一些message可能会被无法传递,所以这个方法是不安全的。可以考虑使用quitSafely()方法来确保所有的工作有序地完成。

        /**
         * Quits the looper safely.
         * <p>
         * Causes the {@link #loop} method to terminate as soon as all remaining messages
         * in the message queue that are already due to be delivered have been handled.
         * However pending delayed messages with due times in the future will not be
         * delivered before the loop terminates.
         * </p><p>
         * Any attempt to post messages to the queue after the looper is asked to quit will fail.
         * For example, the {@link Handler#sendMessage(Message)} method will return false.
         * </p>
         */
        public void quitSafely() {
            mQueue.quit(true);
        }
    

    安全退出循环
    调用quitSafely()方法会使循环结束,只要消息队列中已经被传递的所有消息都将被处理。然而,在循环结束之前,将来不会提交处理延迟消息。
    调用退出后,所有尝试去发送消息都将失败。就像调用Handler.sendMessage(Message)将返回false。

    MessageQueue.mQueue.quit(boolean safe);

        void quit(boolean safe) {
            //当mQuitAllowed为false,表示不运行退出,强行调用quit()会超出异常
            //mQuitAllowed 是在Looper构造函数里面构造MessageQueue()以参数参进去的
            if (!mQuitAllowed) {
                throw new IllegalStateException("Main thread not allowed to quit.");
            }
    
            synchronized (this) {
                // 防止多次执行退出操作
                if (mQuitting) {
                    return;
                }
                mQuitting = true;
    
                if (safe) {
                    //移除尚未触发的所有消息
                    removeAllFutureMessagesLocked();
                } else {
                    //移除所有消息
                    removeAllMessagesLocked();
                }
    
                // We can assume mPtr != 0 because mQuitting was previously false.
                 //mQuitting=false,那么认定mPtr!=0
                nativeWake(mPtr);
            }
        }
    
    
        当safe=true,只移除尚未触发的所有消息,对于正在触发的消息并不移除
        当safe=false,移除所有消息
    

    相关文章

      网友评论

          本文标题:Android-Looper

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