调用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;
    }

quit()方法结束looper循环：

    public void quit() {  
        // 创建一个空的message，它的target为NULL，表示结束循环消息  
        Message msg = Message.obtain();  
        // 发出消息  
        mQueue.enqueueMessage(msg, 0);  
    }  

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

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

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

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

那么，我们如何往MQ上添加消息呢？下面有请Handler！（掌声~~~）

异步处理大师 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;  
        }  
      
        // 其他方法  
    }  

下面我们就可以为之前的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后的效果如下图：