Handler的主要用途有两个：(1)、在将来的某个时刻执行消息或一个runnable,(2)把消息发送到消息队列。

   主要依靠post(Runnable)、postAtTime(Runnable, long)、postDelayed(Runnable, long)、sendEmptyMessage(int)、sendMessage(Message)、sendMessageAtTime(Message)、sendMessageDelayed(Message, long)这些方法来来完成消息调度。post方法是当到Runable对象到达就被插入到消息队列；sendMessage方法允许你把一个包含有信息的Message插入队列，而且它会Handler的handlerMessage(Message)方法中执行(该方法要求在Handler的子类中实现)。

1.构造方法

 /**   默认的构造方法，handler是和当前线程的队列关联在一起，如果队列不存在，那么handler就不能接受消息。
     * Default constructor associates this handler with the {@link Looper} for the
     * current thread.
     * 如果线程没有looper，就会抛出异常
     * If this thread does not have a looper, this handler won't be able to receive messages
     * so an exception is thrown.
     */
public Handler() {
        this(null, false);
    }
//传入一个callback接口用于处理handler传递的Message。
 public Handler(Callback callback) {
        this(callback, false);
    }

//给变量赋值  
public Handler(Callback callback, boolean async) {
        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());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
    
public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

　　方法都差不多，主要是完成了赋值的过程，还有几个没粘贴，但是都差不多。。。

2.变量

/*
     设置这个标记为true来检测不是静态的匿名,本地或成员类继承Handler类。这些类型的类可以带来潜在的泄漏。在Handler的构造方法里面使用到了这个参数，目的就如上所述。
     */
    private static final boolean FIND_POTENTIAL_LEAKS = false;
    final MessageQueue mQueue;
    final Looper mLooper;
    final Callback mCallback;  //回调接口
    final boolean mAsynchronous;
    IMessenger mMessenger;

　　接着下面就是Callback接口：

 /**
     * Callback interface you can use when instantiating(实例化) a Handler to avoid
     * having to implement(实现) your own subclass of Handler.
     * @param msg A {@link android.os.Message Message} object
     * @return True if no further handling is desired
     */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }

callback接口你可以在实例化的时候用，避免去实现你自己的handler子类

这个Callback接口里只有一个handleMessage方法返回boolean值，在后面Handler的ctor会用到，一般情况下都是null。这个接口的存在

没什么特殊的含义，只是为了让你不extends Handler就能处理消息而已（正如此方法的doc所说），类似Thread和Runnable接口的关系。

3.handleMessage

/**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }

子类需要实现这个方法，因为这是个空方法。

4.dispatchMessage?

/**
     * 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);
        }
    }
private static void handleCallback(Message message) {
        message.callback.run();
    }

它的处理是如果message自身设置了callback，则

直接调用callback.run()方法，否则Callback接口的作用就显现了；如果我们传递了Callback接口的实现，即mCallback非空，则调用它处理

message，如果处理了，返回