2019-08-12: 说说你对Handler的理解(源码角度)?

[MicroKibaco]

[ArtarisCN]

Handler 是帮助我们从一个线程向主线程线程发消息的一个机制。

在创建 Handler 时会获取当前 Looper 如果不存在则会报错，就是说创建 Handler 一定要先有与之关联的 Looper，:Looper.perpare(),Looper.loop()

Looper.loop()会一直从 MessageQueue 中获取 Message 进行处理。
loop() 里调用了 MessageQueue.next()获取消息处理，并调用了 msg.target.dispatchMessage(msg) ，msg.target 就是发送该消息的 Handler，这样就回调到了 Handler 那边去了:

Looper:它在消息机制里是用来把普通线程转成looper线程的（Looper.prepare()），并担当消息循环的任务，当然，UI 线程是通过Looper.PrepareMainLoper()。
它会开启无限循环(Loper.loop())并不停的从 MessageQueue 中查看是否有新消息，如果有就拿出来处理，如果没有呢，就阻塞（其实真正的阻塞在 MessageQueue 的 next 里）。Loper在构造的时候会构建一个 MessageQueue 并持有它的引用。

MessageQueue: 消息队列，它用来插入（enqueueMessage），读取消息（next）。它虽然是个消息队列，但实际实现是个单链表，因为单链表在插入和读取上有优势。它插入是根据时间戳排序来的，根据时间戳的排序来指定next的下一条消息。而当next读取的时候，如果有消息，就取出来，如果没有，就阻塞。如果 next 取出来是 null，那么就表示整个app可以结束运行了。

Handler 的主要工作就是负责消息的发送和接收了。发送消息是 post 和 send 的一堆函数，其实到最后 enqueueMessage() 来进行入队，接收消息处理则是通过msg的next里返回的 looper 在交给 handler 的 dispatchMessage() 方法。Handler 在哪个线程之下构造就会持有当前这个线程的 looper 引用。Handler 工作的时候首先会判断 msg.callback（Runnable对象）是不是 null，不为 null 就会变为 handlerCallback（执行msg的callback），然后检查 mCallback 是不是 null，不为 null 执行 handlerMessage。而这个 mCallback 则又是通过 msg 的 target（对应的handler）来进行回调调用的。

[liu1813565583]

  一开始接触android的同学应该都知道，一般情况下android是不能在子线程中更新ui的。要更新ui界面的时候我们就需要用到android给我们提供的Handler机制。  
Handler机制中核心的几个类有Handler、Looper、MessageQueen、Message这四个类，下面我们来一一剖析。  
首先来谈谈Handler的用法（HOW）：
Handler中发送消息的函数可以分为两类：一类是post系列，一类则是sendMessage系列。

• post系列中包括如下方法：

post（Runnable）
postAtTime（Runnable， long）
postDelayed（Runnable， long）   

方法的具体意义这里不做解释，不知道的朋友可以去查下文档。post方法是容许你排列一个Runnable的线程对象到主线程队列中，具体的实现我们待会儿再看。

   sendMessage系列中包括的方法也大致和post中的差不多

sendEmptyMessage（int）
sendMessage（Message）
sendMessageAtTime（Message，long）；
 sendMessageDelayed（Message， long）；

• Handler类的部分源码：

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
public final boolean postAtTime(Runnable r, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }

  如上是Handler中的post（Runnable）的方法，我们可以看到实际上是调用的Handler中的sendMessagexx系列的方法，所以这两种实际上是相同的。然后下面我们来看看sendMessageAtTime方法：

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }

  请大家看最后一行，我们可以看到sendMessageAtTime方法最后的结果enqueueMessage，enqueueMessage我想不用说看字面意思都应该很好理解就是一个将msg放入消息队列，也就是MessageQueue中，还有大家看到上面的一个判断queue==null，如果queue为null的画则会抛出错误，这也就是说我们在sendMessage方法之前必须先新建一个messageQueue，在Android中UI线程在启动时就给我们建立了一个MessageQueue，大家不信可以去看看相关源码，这里不多做解释，然后如果我们要在自己的子线程中用到拥有自己的Handler处理，则需要在子线程中维持一个该线程的MessageQueue，那么这个MessageQueue是怎样产生的呢，下面来看到Looper类，对就是Looper类：

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}
public static void prepare() {
    prepare(true);
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

  就是在这里，我们在子线程中自己管理Looper对象的时候往往都会这样使用

class LooperThread extends Thread {
 public Handler mHandler;

    public void run() {
       Looper.prepare();

        mHandler = new Handler() {
           public void handleMessage(Message msg) {
             // process incoming messages here
             }
        };

         Looper.loop();
   }
  }

  上面是Looper类中的注释，介绍对Looper的使用，注意顺序 Looper.prepare(); XXX; Looper.loop()这样的顺序，仔细看前面prepare的函数通过调用此函数我们可以得到一个MessageQueue的对象，也就是说MessageQueue的对象是在这里产生的，所以Android给我们的使用示例会先调用prepare然后再是loop.
  还有一点需要注意一个子线程最多只能有一个MessageQueue对象，如果你调用两次prepare则会产生Only one Looper may be created per thread的异常，我相信很多人应该都遇到过这个异常吧，反正本人初学Android之时是遇到过，后来解决了，只是不知道为什么会这样，这就是原因。

if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }

  loop函数则是一个死循环不断的去取MessageQueue中的Message来，然后去执行里边的逻辑。那么还有一个很重要的问题没有解决，那就是当looper取到MessageQueue里边的Message之后，我们都知道这时候应该要执行我们的Handler类中的

handleMessage(Message msg) {
}

  此方法了，最后由我们客户端去实现handleMessage的具体逻辑，对吧？那么问题是怎么来的，还有Looper取到的Message怎么知道应该执行哪一个handler的handleMessage方法呢？要知道我们可能在程序中声明很多个handler，那么我们接着往下看Message类

103 /*package*/ Handler target;

  在Message类中的103行声明有一个target变量，对就是这个target！这个target变量存储的就是对这个消息是属于哪一个Handler的一个引用，也就是说这个消息需要哪个Handler来处理。就是它！这样就全部联系起来了是吧。

  我们再次回过头去看Looper类中的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 (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }

        // This must be in a local variable, in case a UI event sets the logger
        Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        msg.target.dispatchMessage(msg);

        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

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

        msg.recycleUnchecked();
    }
}

  大家仔细看看上面的代码for(;;)里边的内容就是我上面所说的不断循环去读取Messagequeue中的Message当读取到其中一个Message后执行了这行代码：

msg.target.dispatchMessage(msg);

  由上面的讲解我们知道msg.target是一个Handler对象这样我们就回到了我们Handler类的dispatchMessage方法，有人会问不对呀我们最后都是在HandlerMessage方法中处理的呀，先别捉急，心急可是吃不了热豆腐哦，我们来看这个dispatchMessage方法到底是何方神圣，好回到Handler类了：

/**
 * Handle system messages here.
 */
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

  这个函数很简单，大家看到没有这里有两种处理方法，第一种当msg.callback不为空则执行handleCallback，第二种当msg.callback为空的事后则执行了我们所熟悉的handlerMessage方法，我想第二种方式大家应该都知道，handleMessage大家应该都重写过这个方法。
  那么来说说第一种，回到最开始，我们最初的起点就是这里，绕了一圈又回来来的！我们最开始的时候说了，Handler发送消息分为两个系列，虽然这两个系统在发送消息时都会调用同一个函数，但是在回调处理的时候还是略有不同。第一种就是post(Runnable)，我们都知道Runnable是一个线程，那么我们可以猜想handleCallback应该是执行我们线程里边的run方法，这样才合理嘛，回调回来。
  那我们下面就看看是不是这样的

private static void handleCallback(Message message) {
    message.callback.run();
}

  看到没有我们的大Android系统果然没有让我们失望，就一句好执行回调的run方法。
  最后回头来看我们handler发送消息的两种方式，分别对应上面说的两种回调方式，一目了然有木有！

handler.post(new Runnable() {
@Override
public void run() {
     //anything what you can do
}
})

mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };
mHandler.sendMessage(msg）

[MicroKibaco]

开讲前,先思考以下几个问题:
  1. 假如入我们要自己定制一个Handler,你会考虑怎么做?
  2. 让你设计一个线程池，如果调用者在传入的Runnable任务时，在run方法直接使用了Handler，会发生什么?
  3. IntentService里面也有一个Handler，它是如何结束执行呢，如果多次start这个IntentService，它又如何判断什么时候结束呢？
  4. Android 子线程为什么不能访问UI? 一定不能访问UI吗?
了解这些问题我们首先需要了解Handler的本质,Handler实质是在指定线程中运行代码.下面就开始我们的Handler源码之旅吧~

一.ThreadLocal

  Handler 的ThreadLocal 是给每一个线程都分配了内容,泛型里面分配了Thread对象.我们用Integer模拟一下ThreadLocal原理
运行以下example:

 final ThreadLocal<Integer> mThreadLocal = new ThreadLocal<>();
   mThreadLocal.set(1);
        Log.e("ThreadLocalTest","thread0"+mThreadLocal+"");


        new Thread("thread1"){
            @Override
            public void run() {
                mThreadLocal.set(2);
                Log.e("ThreadLocalTest","thread1"+mThreadLocal.get()+"");
            }
        }.start();

        new Thread("thread2"){
            @Override
            public void run() {
                 Log.e("ThreadLocalTest","thread2"+mThreadLocal.get()+"");
            }
        }.start();

结果是:

ThreadLocalTest: thread0 1
ThreadLocalTest: thread1 2
ThreadLocalTest: thread3 null

  显然,在不同的线程访问同一个ThreadLocal的get对象,结果却是不一样的.ThreadLocal有这样的结果,其实核心就是ThreadLocal内部会从各自的线程取一个数组.为什么ThreadLocal可以做到互不干扰呢?看一下set源码:

    public void set(T value) {
        Thread t = Thread.currentThread();
        // 通过ThreadLocalMap 获取 当前线程的ThreadLocal
        ThreadLocalMap map = getMap(t);
        if (map != null)
            

      map.set(this, value);
        else
        // 如果map为空就创建一个新的Map,存储当前线程的ThreadLocal
            createMap(t, value);
    }

  我们再来看看 createMap 做了一件什么样的事情.

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
    
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

  涉及复杂的存储算法,不细看了,只要知道,每次拿到一个新的 ThreadLocal 都会设置一个标志位就行了,保证对象唯一性.
  我们再来看一下get的用法:

    public T get() {
        Thread t = Thread.currentThread();
        //  通过getMap方法获取ThreadLocalMap数据, ThreadLocalMap里面存储了ThreadLocal,
        ThreadLocalMap map = getMap(t);
        if (map != null) {
         // 不为空就返回这个对象的ThreadLocalMap.Entry value引用
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        
        // ThreadLocalMap 为空,由setInitialValue描述
        return setInitialValue();
    }

  get的逻辑比较清晰,代码有相关注释.

二.MessageQueue

  MessageQueue主要包含两个操作: 插入和读取对应的方法分别为 enqueueMessage 和 next,我们先来看看enqueueMessage 的源码:

   /**
    单例表插入:往消息队列插入一条消息,MessageQueue其实并不是用的队列,而是一个单例表结构.
    */
    boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
              
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p;  
                prev.next = msg;
            }

         
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

  接下来,我们来看看 next方法:

    Message next() {
       
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        int pendingIdleHandlerCount = -1; 
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
             
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                   
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                         
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                       
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                
                    nextPollTimeoutMillis = -1;
                }
 
                if (mQuitting) {
                    dispose();
                    return null;
                }
 
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }
 
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null;  

                boolean keep = false;
                try {
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }

                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }
 
            pendingIdleHandlerCount = 0;
 
            nextPollTimeoutMillis = 0;
        }
    }

  next方法也是单链表结构,因为单链表在插入和读取上有优势。它插入是根据时间戳排序来的，根据时间戳的排序来指定next的下一条消息。

  而当next方法读取的时候，如果有消息，就取出来，如果没有，就阻塞。

  如果 next 取出来是null，那么就表示整个app可以结束运行了。

三.Looper

  Looper扮演着消息循环的角色,具体来说就是在不同的MessageQueue中查看是否有新的消息.

  如果有新的消息就会立即处理,否则就一直堵塞在这里.首先,我们看一下相关的构造方法.在构造方法中会创建MessageQueue即消息队列,把当前线程的对象保存起来.
  

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

  Handler工作中需要Looper,没有Looper的线程就会报错,那么如何为一个线程创建Looper呢,我写了一段示列代码如下:

  new Thread("Looper"){
            @Override
            public void run() {
             // Looper.prepare()即可为当前线程创建一个Looper
             Looper.prepare();
             Handler handler = new Handler();
             // 通过Looper.loop()开启消息循环.
             Looper.loop();
            }
        }.start();

   Looper除了提供 prepare 方法外,还提供了 prepareMainLooper,这个方法主要是给主线程也就是ActivityThread创建Looper使用的,其本质也是通过prepare 实现的.

  由于主线程的Looper比较特殊,所以Looper提供一个getMainLooper方法,通过它可以获取任意主线程的Looper.

  prepare和prepareMainLooper的区别是:quit会直接退出Looper,而quitSafety只是设置一个退出标记.然后把所有消息队列已有的消息处理完毕安全退出.

  Looper退出后,通过Handler发送消息会失败,这个时候Handler的send会返回false.在子线程中.

  如果手动为其创建了Looper,那么所有的事情完成之后应该调用quit来终止循环,否则这个子线程就会一直处于等待状态,而如果退出Looper以后,这个线程就会终止,因此,建议不需要的时候终止Looper.

  下面我们重点介绍Looper.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.");
        }
        // 当looper的quit方法被调用的时候,Looper就会调用MessageQunue的quit或quitSafety通知消息队列退出
        final MessageQueue queue = me.mQueue;

         // 当消息队列标记为退出状态,next就会标记为null,也就是Looper必须退出,否则Looper会一直无限循环下去.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
   // loop方法是个死循环
        for (;;) {
   // 可能会被阻塞
            Message msg = queue.next(); 
   // 唯一跳出这个方法的是 queue.next 返回为null
            if (msg == null) {
     // loop会调用 MessageQueue 的 next 方法获取新的信息,looper会处理这条信息.
                return;
               
            }

            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
           
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
            // msg.target.dispatchMessage(msg),这里的 msg.target 是发送这条消息的handeler对象
                msg.target.dispatchMessage(msg);
                 // handler对象最终又交给disPatchMessage处理了
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            // 不同的是,Handler所使用的dispatchMessage方法是在创建Handler时使用的Looper执行的.这样就造成将代码切换到指定线程中执行了
            if (slowDispatchThresholdMs > 0) {
                final long time = end - start;
                if (time > slowDispatchThresholdMs) {
                    Slog.w(TAG, "Dispatch took " + time + "ms on "
                            + Thread.currentThread().getName() + ", h=" +
                            msg.target + " cb=" + msg.callback + " msg=" + msg.what);
                }
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

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

            msg.recycleUnchecked();
        }
    }

四.How does Handler Work ?

时间关系,周末总结~

五.Main Thread Message Loop

时间关系,周末总结~

六.Conclusion

  说了这么多,看别人的东西始终是别人的,我们不如简单的用Thread实现一下Handler吧,帮助大家更好的理解Handler的运行流程

    private Handler mThread = new Handler();

    @Override
    public void runTest() {
        mThread.looper.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mThread.looper.setTask(new Runnable() {
            @Override
            public void run() {
                System.out.println("Welcome to join us!CrazyDailyQuestion~~~");
            }
        });
        mThread.looper.quit();
    }

    class Looper extends Thread {

        private Runnable task;
        private boolean quit;

        synchronized void setTask(Runnable task) {

            this.task = task;

        }


        synchronized void quit() {

            quit = true;

        }

        @Override
        public void run() {
            while (quit) {
                synchronized (this) {

                    if (task != null) {
                        task.run();
                        task = null;
                    }
                }
            }
        }
    }


    class Handler {

        Looper looper = new Looper();

    }

  以上代码基本就是Handler简易版本,可能有bug,不过看懂我上面写的,再去理解Handler源码会轻松很多.如果大家对本文存在疑惑,欢迎到每日一问留言.

[pioneerz]

Handler总结：https://www.jianshu.com/p/07cf29542368

[chengying1216]

着重学习了南尘的这篇文章https://www.cnblogs.com/liushilin/p/11234107.html

[zhengjunke]

Handler用于封装消息的发送，先介绍与Handler相关的几个元素：
一、Message：消息,Handler接收和处理的消息对象;
二、Looper：一个消息轮询机制，每个线程只能拥有一个Looper.它的loop方法负责读取MessageQueue中的消息,读到消息之后就把消息发送该消息的Handler处理.
三、MessageQueue:消息队列.
Handler内部会跟Looper进行关联,也就是说在Handler内部可以找到Looper,找到Looper也就找到了MessageQueue,在handler中发送消息,就是向MessageQueue队列中发送消息.
下面讲一下具体细节:
默认整个应用程序都是通过ActivityThread创建,在ActivityThread中创建Activity,默认创建main线程,在线程中默认创建Looper;在Activity的main方法中,调用Looper.prepareMainLooper(), 在prepareMainLooper()中调用prepared(),调用ThreadLocal.set(new Looper()), 传入了一个Looper对象, 在new Looper()这个构造方法中, 先new 出一个MessageQueue(), 并将当前执行的线程对象赋值给Handler的Thread对象.

Handler和Looper的MessageQueue关联: 通过刚才的代码, 在Handler中调用Looper.myLooper(), 通过ThreadLocal.get(), 拿到Looper对象, 再通过该对象拿到MessageQueue. 通过for循环轮询队列, 找到消息的话, 通过msg.target.dispatchmessage(msg), 也就是Handler.dispatchMessage方法, 该方法首先会调用callback的handleMessage(), 如果这个方法执行返回true, 则代表该callback消费了该消息事件, Handler的handleMessage()将不会执行.

[gys0000]

....搞了半天，鼠标移动，全部没了。
因为Android常用到的就是主线程创建Handler，然后子线程使用这个Handler对象发送消息给子线程。我就来梳理；一下这个吧，比较简单。
主要的步骤：主线程创建Handler，获取到looper中的消息队列；子线程中使用Handler穿件消息，并调用sendMessage方法将消息放到消息队列中；主线程的mainLooper早在进程创建的时候，程序的入口main方法中就已经创建了，调用looper的loop方法遍历消息队列，然后通过Handler的handleMessage方法回调到主线程中。
1.创建Handler，并得到消息队列MessageQueue

public Handler(Callback callback, boolean async) {

        mLooper = Looper.myLooper();
      
        mQueue = mLooper.mQueue;
       
    }

2.消息的创建，并放到消息队列中
消息的创建就先忽略，直接一路跟踪sendMessage方法，看到enqueueMessage()方法

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
       //这一步是将handler放到msg中，做个标记，类似于四代目火影的飞雷神标记
        msg.target = this;
      //这一步就是将消息存放到消息队列中
        return queue.enqueueMessage(msg, uptimeMillis);
    }

3.看一下主线程的looper的创建，以及looper的工作原理

class ActivityThread{
    public static void main(String[] args) {
       //在程序的入口就创建了mainLopper对象，并执行了loop方法，循环遍历消息队列
        Looper.prepareMainLooper();
        Looper.loop();
    }
}

class Looper{
     private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

     public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            sMainLooper = myLooper();
        }
    }
    public static void loop() {
        final Looper me = myLooper();
        final MessageQueue queue = me.mQueue;
        for (;;) {
            //构建一个死循环，然后遍历消息队列
            Message msg = queue.next(); // might block
            try {
                //刚才的飞雷神标记起作用了，这里获取到msg里的handler对象，然后执行dispatchMessage方法
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
      }
   }
}

5.最后我们看下dispatchMessage()方法的执行

 public void dispatchMessage(Message msg) {
            handleMessage(msg);
 }

总结一下：跨线程传递消息，背后必将又一个死循环在遍历或者是一直等待消息。主线程中的handler机制比较简单，在程序入口就创建了无限循环方法loop()，如果有子线程发消息到队列中，loop中的死循环就会遍历队列并获取这个消息，然后将消息回调给主线程。

[skylarliuu]

Android的Handler可以指定在某个运行中的线程中执行代码，一般我们会在子线程中做一些耗时操作，然后再借助Handler切换到主线程更新UI。Handler具备这种特性跟Looper、MessageQueue有密不可分的关系。

Handler的工作流程：

1. Handler发送消息 handler.sendMessage(msg)，这条message会记录发送的handler为target
2. sendMessage会调用到与Handler关联的Looper中的messageQueue.enqueueMessage()
3. enqueueMessage()就是向将message插入到MessageQueue中
4. 线程开始执行时，就会启动绑定的Looper，Looper.loop()让Looper一直循环地从内部的MessageQueue.next()方法中取Message。
5. MessageQueue.next()如果取到了Message就返回给Looper，Looper再把message交由message.target（即发送这条message的handler）去处理，如果当前没有消息，Looper就会阻塞，当前线程也会释放掉CPU进入休眠状态，直到有新消息来才被唤醒。
6. 最终调用到handler.dispatchMessage()中处理消息，dispatchMessage()方法是在创建Handler时所使用的Looper中执行的，这样就成功地将代码逻辑切换到指定的线程中去执行了。

Looper在哪个线程创建的，loop()就运行在哪个线程中，同样dispatchMessage()也是在这个线程执行。mainLooper是在 Android的主线程ActivityThread的main方法中调用Looper.prepareMainLooper()中初始化的，所以mainLooper是运行在主线程中的。而Handler的默认Looper就是mainLooper，所以能很方便地用Handler切换到主线程。

[liyilin-jack]

hadler的实现其实是个很复杂的问题（对我这个小白来说），不仅涉及到java相关的实现，Android为了保证消息机制在底层也可以使用，相关实现其实是放在native当中的，java层中的Looper对象持有一个nativeMessageQueue的指针引用mPtr，通过这个指针来调用native层的方法。

从设计的角度考虑，Android应该是“消息驱动”的，也就是主线程的UI更新都是依赖于消息的收发的。要实现“消息驱动”，首先要有一个消息队列来对消息进行维护，其次要对消息进行初始化和消息循环。

具体到Android实现当中，消息循环是用Looper来维护的，主线程的Looper对象是其他线程共享的，其他线程的Looper都存在各自的线程本地变量(ThreadLocal)当中；Lopper中持有的MessageQueue对象是消息队列的具体实现，Looper.loop()方法会对消息队列进行循环读取，MessageQueue.next方法会从消息队列中循环取消息（这个操作是用加锁的方式来实现的线程安全），此时消息创建和消息循环的流程就都有了。

还剩最后一部分就是消息发送。现在我们可以在主线程中，用mainLooper来循环读取消息，那其他线程也还需要往这个消息队列中插入消息。Android中的消息发送是用Handler来实现的。Handler负责为发送消息和接收提供接口。这一块还没有深入了解，待补充。