Looper

最新推荐文章于 2022-10-15 14:58:34 发布

Zac_T

最新推荐文章于 2022-10-15 14:58:34 发布

阅读量303

点赞数

本文链接：https://blog.csdn.net/ztzt15/article/details/50099957

版权

activity/service启动时，会启动三个线程。一个主线程和两个Binder线程

主线程在ActivityThread的main方法中启动

public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();
        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);
        Environment.initForCurrentUser();
        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());
        AndroidKeyStoreProvider.install();
        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);
        Process.setArgV0("<pre-initialized>");
        <span style="color:#ff0000;">Looper.prepareMainLooper();</span>
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        if (sMainThreadHandler == null) {
            <span style="color:#ff0000;">sMainThreadHandler = thread.getHandler();</span>
        }
        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }
        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        <span style="color:#ff0000;">Looper.loop();</span>
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

顺藤摸瓜，我们先去看看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()}
     * <span style="color:#3333ff;">初始化当前线程作为looper对象，标记它作为应用程序的main looper。这个main looper 是android自动为你创建的，所以你永远不需要调用这个方法。</span>
     */
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            <span style="color:#ff0000;">sMainLooper = myLooper();</span>
        }
    }

根据方法的注释我们可以看到，这个是由系统调用的。并且不建议我们自行调用。

在这个方法中又调用到了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()}.
      * 初始化当前线程作为looper对象。这个给你一个机会可以在真正启动一个loop之前去创造handlers并且与looper对象建立关联。
<span style="white-space:pre">	</span>确保你调用了loop()方法，在调用prepare()方法之后。
      */
    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        <span style="color:#cc0000;">sThreadLocal.set(new Looper(quitAllowed));</span>
    }

很明显，在prepare方法中，创建了一个Looper对象，并且在Looper的构造函数里，创建了MessageQueue对象，并赋值给了mQueue这个成员变量。再去看看sThreadLocal这个变量

//  sThreadLocal.get() will return null unless you've called prepare().
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

明显可以看到，这个变量是用来存Looer对象的，而且在prepare中完成了set赋值操作，所以注释说，get方法会返回null，如果没有调用prepare方法。

ok，这里可以为prepareMainThread做个小总结了。简单一句话：

创建一个与主线程相关联的Looper对象，并且存入sThreadLocal中。

咱们继续往下看Looper.loop()方法

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     * <span style="color:#3333ff;">在线程中启动Message队列。</span>
     */
    public static void loop() {
        <span style="color:#ff0000;">final Looper me = myLooper();</span>
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
       <span style="color:#ff0000;"> final MessageQueue queue = me.mQueue;</span>

        // 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();

       <span style="color:#ff0000;"> for (;;) {</span>
            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
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            <span style="color:#ff0000;">msg.target.dispatchMessage(msg);</span>

            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.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                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);
            }

            msg.recycleUnchecked();
        }
    }

ok，loop方法比较长，咱们一点一点分析，先看myLooper()

   /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     * <span style="color:#3366ff;">返回与</span><span style="color:#993399;">当前线程</span><span style="color:#3366ff;">相关联的Looper对象。  如果调用的线程没有和一个Looper相关联则返回null</span>
     */
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

代码很简单，就是从sThreadLocal中取出looper对象，因为之前sThreadLocal已经将与当前线程通过set方法存入了，所以返回值不会为null

接下来继续看MessageQueue queue = me.mQueue这行代码

先分析一个，这行代码的意思应该是将Looper对象中的messageQueue对象的内存地址赋值给当前prepare中创建的Looper中的MessageQueue对象

继续看一下for(,,)

这是一个死循环，从队列中不停的取出Message，如果没有直接返回如果有Message，则调用该Message对象的

这里可以做一个总结了：

Looper的创建以及与之绑定的MessageQueue关系已经明朗，它们之间是一对一的关系

继续向下看

target.dispatcher(msg)方法

target是Handler对象，也是Message的成员变量，我们一起看一下它是如何被赋值的，到底是与谁相关联的呢？