概念

网上有很多Handler的文档，写的很详细，但有时越详细的文章看起来越是云里雾里，比如说 一个线程能否创建多个Handler，Handler跟Looper之间的对应关系等等，感觉越绕越晕，如果大家也有这方面的困惑，不妨花些许时间来看看这篇文章；
文章从最简单的概念来理解Handler；

ThreadLocal

首先要了解ThreadLocal的作用，ThreadLocal是一个线程内部的数据存储类，数据存储有只有当前线程能够获取对应数据，别的线程无法获取到。
上面的介绍可能大家理解起来有点抽象，我们通过代码来理解会比较直观；

public static void main(String[] args) {
    // 定义一个ThreadLocal 对象，泛型使用的Integer，分别在主线程，Thread_1 和 Thread_2中设置、访问 threadLocal 的值；
     ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
     threadLocal.set(5);
     new Thread("Thread_1") {
         @Override
         public void run() {
             for (int i = 0; i< 10;i++) {
                 threadLocal.set(i);
             }
            System.out.println(Thread.currentThread().getName() + ", " + threadLocal.get());
         }
     }.start();

     new Thread("Thread_2") {
         @Override
         public void run() {
             for (int i = 11; i< 20;i++) {
                 threadLocal.set(i);
             }
             System.out.println(Thread.currentThread().getName() + ", " + threadLocal.get());
         }
     }.start();
     System.out.println(Thread.currentThread().getName() + ", " + threadLocal.get());
 }

output

Thread_1, 9
main, 5
Thread_2, 19

从打印的日志可以看出，虽然不同线程访问的是同一个ThreadLocal对象，但不同线程获取到的值是不同的，这就是ThradLocal的作用；

---

为一个线程创建Looper，开启消息循环

我们来为一个线程创建Looper，并开启消息循环，然后再把各个关键代码抽离处理，耦合在一起，这样便于大家对线程切换有个比较直观的理解；

new Thread() {
    @Overvide
    public void run() {
        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();
    }
}.start();

我们可以把这段代码解耦的部分抽出来，写的更加直观一些；

private Handler handler
new Thread("Thread_Looper") {
    @Overvide
    public void run() {
        // Looper.prepare(); 创建Looper，并为ThreadLocal赋值
        Looper looper = new Looper(); 
        {
            mQueue = new MessageQueue(quitAllowed);
        }
        sLocalThread.set(looper);

        // Handler handler = new Handler();
        handler = new Handler();
        {
            // 获取当前线程的Looper
            mLooper = Looper.myLooper();
            mQueue = mLooper.mQueue;
        }

        // Looper.loop(); loop()是静态方法，里面是一个for循环（for死循环）
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        for(;;) {
            Message msg = queue.next(); // might block
        }
    }
}.start();

// 调用Handler往 Thread_Looper 线程发送消息
new Thread("Thread_SendMessage") {
    @Overvide
    public void run() {
        // mHandler.sendMessage();
        queue.enqueueMessage(msg, uptimeMillis);
    }
}

看到这里，Handler切换线程的逻辑应该就很好理解了，Handler持有Looper对象的MessageQueue，线程（Thread_SendMessage）调用 handler.sendMessage()时，实际做的是往Looper对象的MessageQueue中插入消息，线程（Thread_Looper）在for循环中，获取到消息，并处理消息，这就完成了线程切换的过程；

image.png

关键代码

Looper

class Looper {
    static LocalThread sLocalThread;
    Thread mThread;
    MessageQueue mQueue;
    static void prepare() {
        sLocalThread.set(new Looper());
    }
    static Looper myLooper() {
        sLocalThread.get();
    }
    static void loop() {
        Looper me = Looper.myLooper();
        MessageQueue queue = me.mQueue();
        for(;;) {
        }
    }
    Looper() {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }
}

Handler

class Handler {
    Looper mLooper;
    MessageQueue mQueue;
    public Handler() {
        mLooper = Looper.myLooper();
        mQueue = mLooper.mQueue;
    }
    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        return enqueueMessage(queue, msg, uptimeMillis);
    }
    private boolean enqueueMessage(MessageQueue queue, Message msg,
        long uptimeMillis) {
        msg.target = this;
        return queue.enqueueMessage(msg, uptimeMillis);
    }
}