Android 消息机制之深入学习Looper

前言：Looper在Android的消息机制中扮演着消息循环的角色。具体点说就是Looper会不停的从MessageQueue中查看是否有新消息，如果有新消息就会立刻处理，没有就一直阻塞在那里。注意：一个线程有且只能有一个Looper，一个MessageQueue

一，Looper的使用

  class LooperThread: Thread() {

        override fun run() {
            super.run()
            Looper.prepare()
            LooperHandler(Looper.myLooper())
            Looper.loop()
        }
    }

    class LooperHandler(myLooper: Looper) : Handler() {
        //处理消息所在线程取决于Handler对象在哪个线程创建
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            TODO()
        }
    }

下面将围绕上面简短的实例代码对Looper做分析

二，属性介绍

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

    final MessageQueue mQueue;
    final Thread mThread;

    private Printer mLogging;
    private long mTraceTag;

    /* If set, the looper will show a warning log if a message dispatch takes longer than time. */
    private long mSlowDispatchThresholdMs;

sThreadLocal:ThreadLocal有不明白的小伙伴可以到这里看一下：ThreadLocal深入分析（Jdk1.8）

这里的sThreadLocal是确保每一个线程存储与之对应的Looper

sMainLooper:主线程的Looper对象，系统自动为我们创建，这也是为什么我们在主线程中使用Handler的时候不需要手动创建Looper的原因

mQueue:消息队列，存放消息的链表

mThread:与Looper相对应的线程

三，构造方法

 private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

可以看到Looper的构造方法中做了两件事

1，创建一个MessageQueue

2，获取当前线程并保存

在创建Looper的时候就为其指定了一个MessageQueue。

四，prepare();

  public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        一个线程有且只能有一个Looper对象
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

线程默认是没有消息循环与它们绑定的，仅仅是用来处理一些逻辑的。如果我们需要在一个线程中执行消息循环就需要为这个线程指定Looper对象。Looper.prepare();就是这个作用。

sThreadLocal.get();是获取与当前线程对应的Looper对象，如果有就抛出一个异常，因为prepare();方法是为线程指定Looper的初始化入口，所以第一次调用时不应该有Looper对象。如果没有就创建一个Looper对象，存放在ThreadLocal中。默认创建的MessageQueue是可退出的。

五，loop();

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
          ......
           try {
                msg.target.dispatchMessage(msg);
               
            } finally {
               ......
            }
 msg.recycleUnchecked();
        }
    }

 public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

上面的源码是删减版的，只保留了核心代码。

loop();方法是Looper类中的核心方法，作用是不断的从消息队列中取消息，然后将消息指定给msg.target(也就是Handler)处理。具体分析一下：先是调用myLooper();获取Looper对象，如果Looper对象不存在就抛出异常。获取消息队列MessageQueue,然后是一个阻塞循环调用MessageQueue的next();方法取出消息。如果MessageQueue正处于退出状态返回的msg=null直接退出循环，如果取出的msg!=null;就把取出的消息交给msg.target（Handler）处理。最后将这个消息做上标记FLAG_IN_USE,并回收。下面看一下Message中的recyclerUnchecked();

注意一下源码中的系统注释：意思是说调用过loop();方法之后要确保调用quit();退出循环

五，quit();

public void quit() {
        mQueue.quit(false);
    }

public void quitSafely() {
        mQueue.quit(true);
    }

退出方法有两种一种是安全退出方式一种是非安全的退出方式。区别如下：

quit();会直接退出Looper,而quitSafely();只是设定一个退出标记，然后把消息队列中的已有的信息处理完毕后才安全退出。

以上就是对Looper的分析，有不足的地方或是有误的地方欢迎指出。