Android线程的Looper相关知识

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_28656671/article/details/54974403

Android线程的Looper，Handler相关知识

---

Android中的Looper类，是用来封装消息循环和消息队列的一个类，用于在android线程中进行消息处理。Handler其实可以看做是一个工具类，用来向消息队列中插入消息的。

Android官方文档中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 prepare() in
the thread that is to run the loop, and then loop() to have it process messages until the loop is stopped.
Most interaction with a message loop is through the Handler class. 
This is a typical example of the implementation of a Looper thread, using the separation of prepare() and loop() to create an initial Handler to communicate with the Looper.

---

Looper实现原理

1. Looper可以理解为一个类似轮询器
2. Looper在创建的时候，会自动创建一个MessageQueue(消息队列)。
3. 将内部线程对象指向自动创建的线程。
4. 然后当Looper开启的时候，去不断遍历“询问”消息队列，如果没有消息，队列为空，那么就继续轮询
。如果有消息进入队列，则对消息进行处理，回调handler的handlemessage方法进行处理

---

Looper创建的流程

1. Looper类用来为一个线程开启一个消息循环。 默认情况下android中新诞生的线程是没有开启消息循环的。（主线程除外，主线程系统会自动为其创建Looper对象，开启消息循环。） Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper，对应一个MessageQueue。

2. 通常是通过Handler对象来与Looper进行交互的。Handler可看做是Looper的一个接口，用来向指定的Looper发送消息及定义处理方法。 默认情况下Handler会与其被定义时所在线程的Looper绑定，比如，Handler在主线程中定义，那么它是与主线程的Looper绑定。 mainHandler = new Handler() 等价于new Handler(Looper.myLooper()). Looper.myLooper()：获取当前进程的looper对象，类似的 Looper.getMainLooper() 用于获取主线程的Looper对象。

3. 在非主线程中直接new Handler() 会报如下的错误:

   E/AndroidRuntime( 6173): Uncaught handler: thread Thread-8 exiting due to uncaught 
   exception E/AndroidRuntime( 6173): Java.lang.RuntimeException: Can't create handler inside 
   thread that has not called Looper.prepare()

   原因是非主线程中默认没有创建Looper对象，需要先调用Looper.prepare()启用Looper。
   Looper.prepare()相关代码：

   /**
     * 初始化Looper，调用loop()方法开始循环，调用quit()退出
     * 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) {
       if (sThreadLocal.get() != null) {//一个线程只能有一个Looper
           throw new RuntimeException("Only one Looper may be created per thread");
       }
       //保存Looper
       sThreadLocal.set(new Looper(quitAllowed));
   }
   
   /**
    * 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()}
    * 初始化主线程的Looper，不要调用。因为开启主线程的时候系统已经默认开启Looper了再次调用会报异常
    */
   public static void prepareMainLooper() {
       prepare(false);
       synchronized (Looper.class) {
           if (sMainLooper != null) {
               throw new IllegalStateException("The main Looper has already been prepared.");
           }
           sMainLooper = myLooper();
       }
   }
   

   //构造函数
   private Looper(boolean quitAllowed) {
       mQueue = new MessageQueue(quitAllowed);//创建消息队列
       mThread = Thread.currentThread();//绑定当前线程
   }

4. Looper.loop()让Looper开始工作，从消息队列里取消息，处理消息。

   注意：写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop才会中止，其后的代码才能得以运行。
   Looper.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;

        // 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();
        //开始一个死循环
        for (;;) {
            // 从消息队列中获取新的消息，当没有新消息的时候会在queue.next()方法中进行循环遍历
            //直到有新的消息或者调用Looper.quit()
            Message msg = queue.next(); 
            if (msg == null) {//如果返回的消息为空就表示已经调用MessageQueue.quit();并且已经MessageQueue.dispose()
                // No message indicates that the message queue is quitting.
                //Return here if the message loop has already quit and been disposed.
                return;
            }
            //msg.target 是Handler对象，这里进行消息的分发
            msg.target.dispatchMessage(msg);

            // 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);
            }
            //Message对象回收
            msg.recycleUnchecked();
        }
    }

Looper.quit()源码

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

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

1. 基于以上知识，可实现主线程给子线程（非主线程）发送消息。把下面例子中的mHandler声明成类成员，在主线程通过mHandler发送消息即可。

   class LooperThread extends Thread  {  
           public Handler mHandler;  
           public void run()   {  
               Looper.prepare();  
               mHandler = new Handler()   {  
                   public void handleMessage(Message msg)   {  
                       // process incoming messages here  
                   }  
               };  
   
               //这里可以做两个修改UI的操作
               //1，Toast可在这里显示
               //2，Dialog对话框可以显示
               //3，Snackbar可在非UI线程中调用显示，不需要Looper.perpare().因为它的Hander调用的主线程Looper
               Looper.loop();  
               //在调用looper.quit()之前是不会被调用的
           }
       }