final Looper mLooper; // Handler持有Looper实例
final MessageQueue mQueue; // Handler持有消息队列
final Callback mCallback;

public Handler(Callback callback, boolean async) {
    // rustfisher 处理异常
    mLooper = Looper.myLooper();
    // rustfisher 处理特殊情况...
    mQueue = mLooper.mQueue; // 获取的是Looper的消息队列
}

public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue; // 获取的是Looper的消息队列
    mCallback = callback;
    mAsynchronous = async;
}

// 立刻发送一个empty消息
sendEmptyMessage(int what) 

// 发送延迟为0的empty消息  这个方法里通过Message.obtain()获取一个Message实例
sendEmptyMessageDelayed(what, 0) 

// 计算消息的计划执行时间，进入下一阶段
sendMessageDelayed(Message msg, long delayMillis)

// 在这里判断队列是否为null  若为null则直接返回false
sendMessageAtTime(Message msg, long uptimeMillis)

// 将消息添加到队列中
enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

// 接下来是MessageQueue添加消息
// MessageQueue.java
boolean enqueueMessage(Message msg, long when)

public final void removeCallbacksAndMessages(Object token) {
    mQueue.removeCallbacksAndMessages(this, token);
}

void removeCallbacksAndMessages(Handler h, Object object)

/*package*/ Handler target; // 指定的Handler

/*package*/ Runnable callback;

// 可以组成链表
// sometimes we store linked lists of these things
/*package*/ Message next;

public void recycle()
void recycleUnchecked()

/**
 * Same as {@link #obtain()}, but sets the value for the <em>target</em> member on the Message returned.
 * @param h  Handler to assign to the returned Message object's <em>target</em> member.
 * @return A Message object from the global pool.
 */
public static Message obtain(Handler h) {
    Message m = obtain();
    m.target = h;

    return m;
}

/**
 * Sends this Message to the Handler specified by {@link #getTarget}.
 * Throws a null pointer exception if this field has not been set.
 */
public void sendToTarget() {
    target.sendMessage(this); // target 就是与消息绑定的Handler
}

class LooperThread extends Thread {
    public Handler mHandler;
    public void run() {
        Looper.prepare(); // 为当前线程准备一个Looper
        // 创建Handler实例，Handler会获取当前线程的Looper
        // 如果实例化Handler时当前线程没有Looper，会报异常 RuntimeException
        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };
        Looper.loop(); // Looper开始运行
    }
} 

for (;;) {
    Message msg = queue.next(); // might block
    if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
    }

Message next() {
    // ...
    for (;;) {
        // ...
        nativePollOnce(ptr, nextPollTimeoutMillis);
        // 处理message对象

// 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; // Handler会获取这个消息队列实例（参考Handler构造器）
final Thread mThread; // Looper当前线程

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实例存入了sThreadLocal
}

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

// 获取与当前线程关联的Looper，返回可以为null
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

public static void loop()

public static void prepareMainLooper() {
    prepare(false); // 这里表示了主线程Looper不能由开发者来退出
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

public static Looper getMainLooper()

Handler mMainHandler1;
Handler mMainHandler2;

private void initUtils() {
    mMainHandler1 = new Handler(Looper.getMainLooper());
    mMainHandler2 = new Handler(Looper.getMainLooper());
    Log.d(TAG, "mMainHandler1 post 任务");
    mMainHandler1.postDelayed(new Runnable() {
        @Override
        public void run() {
            Log.d(TAG, "mMainHandler1的演示任务已执行 rustfisher");
        }
    }, 1500);
    mMainHandler2.removeCallbacksAndMessages(null);
}

  package com.cdc.handler;
    import android.os.Handler;
    import android.os.Message;
    import android.os.SystemClock;
    //发送消息的⼦线程
    public class Thread1 extends Thread {
         private Handler handler;
         public Thread1(Handler handler){
             super.setName("Thread1");
             this.handler=handler;
         }
         @Override
         public void run() {
             Message msg = Message.obtain();
             msg.what = 1;
             msg.obj = System.currentTimeMillis()+"";
             handler.sendMessage(msg);
             System.out.println((Thread.currentThread().getName() + "----发送了消
息！" + msg.obj));
            SystemClock.sleep(1000);
    }
}

package com.cdc.handler;
    import android.os.Handler;
    import android.os.Looper;
    //接收消息的⼦线程
    public class Thread2 extends Thread{
        private Handler handler2;
        public Handler getHandler(){//注意哦，在run执⾏之前，返回的是null
            return handler2;
        }
        public Thread2(){
            super.setName("Thread2");
        }
        @Override
        public void run() {
            //在⼦线程⾥⾯新建Handler的实例，需要先调⽤Looper.prepare();否则会报
错:Can't create handler inside thread that has not called Looper.prepare()
            Looper.prepare();
            handler2 = new Handler(){
                public void handleMessage(android.os.Message msg) {
                //这⾥处理消息
                System.out.println(("收到消息了：" +
Thread.currentThread().getName() + "----" + msg.obj));
            };
        };
        Looper.loop();
    }
}

private Handler myHandler=null;
private Thread2 thread1;
private Thread1 thread2;
@OnClick(R.id.handler3)
public void handler3(){
    thread1=new Thread2();
    thread1.start();
    myHandler=thread1.getHandler();
    while(myHandler==null){
        SystemClock.sleep(100);
        myHandler=thread1.getHandler();
    }
    thread2=new Thread1(myHandler);
    thread2.start();
}

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can
touch its views.");
     }
 }