Message，MessageQueue，Handler，Looper，Thread，ThreadLocal

Message：单个消息体，承载了两个线程之间交流的信息。不同的消息由"what"来区分。

MessageQueue：消息链表，所有从非UI线程发过来的Message都被加入到这个队列中。其实这个类主要功能就是往mMessage的next加入新的消息，然后提供给Looper获取。

Handler：在非主线程中发送消息，并且在主线程中处理消息。（自己发送给自己，好变态。）

Looper： 遍历MessageQueue中所有没有处理过的消息，发送给Handler处理。

Thread：非主线程。上面所有的东西都是为了该线程和主线程交互数据（比如View）做准备的。

总体流程如下：

UI线程{
           //申请Handler对象。
           Handler mHandler =new Handler(){
           
              @Override
              public void handleMessage(Message msg) {
              
               
              }
           };
           //非主线程
           Thread{
               run(){
                                      
                   0: Handler发送Message
                   1：Message被塞入MessageQueue
                   2: Looper 不断的遍历MessageQueue，取出消息。
                   3：在Looper中回调Handler的 handleMessage(Message msg) 函数。
                   
                    
                    
               }
           }
           //整个过程又回到了UI线程中处理。
        }

总结上面的流程：Handler并没有真正开启另外一个线程，两个线程中通过一个消息队列，实现了数据在两个线程中的"同步"传递。
当然如果只是为了在不同线程间传递数据，直接使用共享变量就可以了。例如可以将Handler的类设置成一个Object对象即可。事实上Handler本身就是个线程中的共享变量。
真正有意义的地方在于：Looper是一个死循环，不断的遍历MessageQueue里面的Message，传递给UI线程的Handler，然后即时的影响UI线程的View的绘画等。整个过程让人感觉是同步操作。

应用层代码：

//注册一个Handler
     private Handler mHandler =new Handler(){
 
        @Override
         public void handleMessage(Message msg) {
            //do some stuffs
         }
         
      };
      //启动一个新的线程：
       new Thread(new Runnable()
         {
              
              
              @Override
              public void run() {
                //在当前线程中生成一个新的Looper对象
                Looper.prepare();
                
                //给MessageQueue队列插入一条消息。
                mHandler.sendEmptyMessage(0);
                
                //不断的轮询遍历MessageQueue的消息，并且发送给mHandler
                Looper.loop();
               }
              

        })start();

源码：
上面的流程中没有看到Looper，MessageQueue，Handler三者之间是怎么建立起练习的。下面部分做出解释:

Looper.java：
    public static void prepare() {
         //生成了一个新的Looper对象并且保存在sThreadLocal的map中。注意这个map的键key是当前线程的标示，也就是Thread.currentThread()。
         //所以每个线程都有一个独立的Looper对象。
         sThreadLocal.set(new Looper());
         
    }
    //在Looper对象的初始化中会创建一个新的MessageQueue
    private Looper() {
        mQueue = new MessageQueue();
    }
    //通过这个函数获取当前线程创建的Looper对象，前面说过了一个线程只能有一个Looper对象，所以该Looper对象就是上面创建的那个。
    public static Looper myLooper() {
        return sThreadLocal.get();
    }


//Looper跟Handler是怎样建立关系的？

Handler.java
    public Handler() {
        //得到当前线程的Looper对象
        mLooper = Looper.myLooper();
        //得到Looper对象的MessageQueue对象的引用
        mQueue = mLooper.mQueue;
    }
 }
 

通过上面两个构造函数就将Looper，MessageQueue，Handler建立起了关系。

消息的分发：

Handler.java
    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis){
        
            MessageQueue queue = mQueue;
            if (queue != null) {
                msg.target = this; //这步很重要：将handler的引用记录在了msg.target中。方便后面Looper处理消息后返还消息给Handler的对象。
                sent = queue.enqueueMessage(msg, uptimeMillis);
                
                return sent;
            }
        }
    }
 MessageQueue.java
    //将新插入的消息放到消息队列的最后
    final boolean enqueueMessage(Message msg, long when) {
        
        Message p = mMessages;
        Message prev = null;
        while (p != null && p.when <= when) {
            prev = p;
            p = p.next;
       }
        msg.next = prev.next;
        prev.next = msg;
    
    }
Looper.java
    //一个死循环
    public static void loop() {
        //得到当前线程的Looper对象
        Looper me = myLooper();
        //得到当前线程的消息队列
        MessageQueue queue = me.mQueue;
        while (true) {
            Message msg = queue.next(); // might block
            if (msg != null) {
                //将消息返还给Handler的对象，调用我们覆盖的函数
                msg.target.dispatchMessage(msg);
                //释放消息队列的中消息
                msg.recycle();
            
            }
        }
    
    }

从建立关系，到分发消息，最后返还消息的过程大概就是这样了。

过程中还设计到了java中管理线程的一个内容

Looper.java
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

这个对象用于保存不同线程中的数据备份，不涉及android内容。