Looper,Handler, MessageQueue

Looper

Looper是线程用来运行消息循环(message loop)的类。默认情况下，线程并没有与之关联的Looper，可以通过在线程中调用Looper.prepare() 方法来获取，并通过Looper.loop() 无限循环地获取并分发MessageQueue中的消息，直到所有消息全部处理。典型用法如下：

 public class LooperThread extends Thread {
     @Override
     public void run() {
         // 将当前线程初始化为Looper线程
         Looper.prepare();

         // ...其他处理，如实例化handler

         // 开始循环处理消息队列
         Looper.loop();
     }
 }

通过上面两行核心代码，你的线程就升级为Looper线程了

1)Looper.prepare()

通过上图可以看到，现在你的线程中有一个Looper对象，它的内部维护了一个消息队列MessageQueue。一个Thread只能有一个Looper对象

 public class Looper {
     // 每个线程中的Looper对象其实是一个ThreadLocal，即线程本地存储(TLS)对象
     private static final ThreadLocal sThreadLocal = new ThreadLocal();
     // Looper内的消息队列
     final MessageQueue mQueue;
     // 当前线程
     Thread mThread;
     // 。。。其他属性

     // 每个Looper对象中有它的消息队列，和它所属的线程
     private Looper() {
         mQueue = new MessageQueue();
         mRun = true;
         mThread = Thread.currentThread();
     }

     // 我们调用该方法会在调用线程的TLS中创建Looper对象
     public static final void prepare() {
         if (sThreadLocal.get() != null) {
             // 试图在有Looper的线程中再次创建Looper将抛出异常
             throw new RuntimeException("Only one Looper may be created per thread");
         }
         sThreadLocal.set(new Looper());
     }
     // 其他方法

通过源码，prepare()背后的工作方式一目了然，其核心就是将looper对象定义为ThreadLocal。如果你还不清楚什么是ThreadLocal，请参考《理解ThreadLocal》

2）Looper.loop()

调用loop方法后，Looper线程就开始真正工作了，它不断从自己的MQ中取出队头的消息(也叫任务)执行。其源码分析如下：

 public static final void loop() {
         Looper me = myLooper();  //得到当前线程Looper
         MessageQueue queue = me.mQueue;  //得到当前looper的MQ

         // 这两行没看懂= = 不过不影响理解
         Binder.clearCallingIdentity();
         final long ident = Binder.clearCallingIdentity();
         // 开始循环
         while (true) {
             Message msg = queue.next(); // 取出message
             if (msg != null) {
                 if (msg.target == null) {
                     // message没有target为结束信号，退出循环
                     return;
                 }
                 // 日志。。。
                 if (me.mLogging!= null) me.mLogging.println(
                         ">>>>> Dispatching to " + msg.target + " "
                         + msg.callback + ": " + msg.what
                         );
                 // 非常重要！将真正的处理工作交给message的target，即后面要讲的handler
                 msg.target.dispatchMessage(msg);
                 // 还是日志。。。
                 if (me.mLogging!= null) me.mLogging.println(
                         "<<<<< Finished to    " + msg.target + " "
                         + msg.callback);

                 // 下面没看懂，同样不影响理解
                 final long newIdent = Binder.clearCallingIdentity();
                 if (ident != newIdent) {
                     Log.wtf("Looper", "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.recycle();
             }
         }
     }

除了prepare()和loop()方法，Looper类还提供了一些有用的方法，比如

Looper.myLooper()得到当前线程looper对象：

 public static final Looper myLooper() {
         // 在任意线程调用Looper.myLooper()返回的都是那个线程的looper
         return (Looper)sThreadLocal.get();
     }

getThread()得到looper对象所属线程：

  public Thread getThread() {
         return mThread;
     }

Handler 避免内存泄漏

1. handler.removeCallbacksAndMessages(null);
2. handler.getLooper().quit();

Looper的quit()方法结束looper循环：

public final class 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;

   public void quit() {
        mQueue.quit(false);//调用MessageQueue退出
   }
 }

MessageQueue 的quit()方法

public final class MessageQueue {
    //...
    void quit(boolean safe) {
        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.
            nativeWake(mPtr);
        }
    }

    private void removeAllMessagesLocked() {
        Message p = mMessages;
        while (p != null) {
            Message n = p.next;
            p.recycleUnchecked();
            p = n;
        }
        mMessages = null;
    }

    private void removeAllFutureMessagesLocked() {
        final long now = SystemClock.uptimeMillis();
        Message p = mMessages;
        if (p != null) {
            if (p.when > now) {
                removeAllMessagesLocked();
            } else {
                Message n;
                for (;;) {
                    n = p.next;
                    if (n == null) {
                        return;
                    }
                    if (n.when > now) {
                        break;
                    }
                    p = n;
                }
                p.next = null;
                do {
                    p = n;
                    n = p.next;
                    p.recycleUnchecked();
                } while (n != null);
            }
        }
    }

    //...
}

通过观察以上源码我们可以发现:
当我们调用Looper的quit方法时，实际上执行了MessageQueue中的removeAllMessagesLocked方法，该方法的作用是把MessageQueue消息池中所有的消息全部清空，无论是延迟消息（延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息）还是非延迟消息。
当我们调用Looper的quitSafely方法时，实际上执行了MessageQueue中的removeAllFutureMessagesLocked方法，通过名字就可以看出，该方法只会清空MessageQueue消息池中所有的延迟消息，并将消息池中所有的非延迟消息派发出去让Handler去处理，quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。
无论是调用了quit方法还是quitSafely方法只会，Looper就不再接收新的消息。即在调用了Looper的quit或quitSafely方法之后，消息循环就终结了，这时候再通过Handler调用sendMessage或post等方法发送消息时均返回false，表示消息没有成功放入消息队列MessageQueue中，因为消息队列已经退出了

到此为止，你应该对Looper有了基本的了解，总结几点：

1.每个线程有且最多只能有一个Looper对象，它是一个ThreadLocal

2.Looper内部有一个消息队列，loop()方法调用后线程开始不断从队列中取出消息执行

3.Looper使一个线程变成Looper线程。

handler

什么是handler？handler扮演了往MQ上添加消息和处理消息的角色（只处理由自己发出的消息），即通知MQ它要执行一个任务(sendMessage)，并在loop到自己的时候执行该任务(handleMessage)，整个过程是异步的。handler创建时会关联一个looper，默认的构造方法将关联当前线程的looper，不过这也是可以set的。默认的构造方法：

public class handler {

    final MessageQueue mQueue;  // 关联的MQ
    final Looper mLooper;  // 关联的looper
    final Callback mCallback;
    // 其他属性

    public Handler() {
        // 没看懂，直接略过，，，
        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());
            }
        }
        // 默认将关联当前线程的looper
        mLooper = Looper.myLooper();
        // looper不能为空，即该默认的构造方法只能在looper线程中使用
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        // 重要！！！直接把关联looper的MQ作为自己的MQ，因此它的消息将发送到关联looper的MQ上
        mQueue = mLooper.mQueue;
        mCallback = null;
    }

    // 其他方法
}

 这里有一个疑问，如果handler在主线程的死循环一直运行是不是特别消耗CPU资源呢？

这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

下面我们就可以为之前的LooperThread类加入Handler：

 public class LooperThread extends Thread {
     private Handler handler1;
     private Handler handler2;

     @Override
     public void run() {
         // 将当前线程初始化为Looper线程
         Looper.prepare();

         // 实例化两个handler
         handler1 = new Handler();
         handler2 = new Handler();

         // 开始循环处理消息队列
         Looper.loop();
     }
 }

可以看到，一个线程可以有多个Handler，但是只能有一个Looper！