【Android】Handler消息机制

🕗 发布于 2024-10-06 14:40 android android studio 学习

文章目录

前言
概述
- 核心组件概述
- Android消息机制概述
Android消息机制分析

前言

本文用于记录Android的消息机制，主要是指Handler的运行机制。部分内容参考自《Android开发艺术探索》，感兴趣可以阅读原书。

概述

核心组件概述

Handler是Android消息机制的上层接口，通过它可以轻松将一个任务从一线程切换到Handler所在的线程执行，如由子线程切换到主线程更新UI。具体来说有时候我们需要在子线程中执行耗时操作，当耗时操作结束时希望将UI更新，这时候我们就需要将线程切换到主线程了，也就是UI线程（因为Android不允许在子线程更新UI）。

Handler的运行需要底层MessageQueue和Looper的支持。MessageQueue也就是消息队列，它可以存储消息并以队列的形式提供插入消息和删除消息操作（注意：虽然叫消息队列，但它内存存储结构并不是队列而是单链表）。Looper我们可以将它理解为消息循环，它会以无限循环的方式去消息队列中查找是否存在消息，有的话就对消息进行处理，没有的话就一直等待。

此外Looper中还有一个特殊的概念——ThreadLocal，ThreadLocal不是线程，它的作用是在每个线程中独立的存储数据。Handler在创建的时候，需要使用当前线程的Looper来构建消息循环系统，，那么如何获取当前线程的Looper呢？此时就要用到ThreadLocal，我们知道ThreadLocal可以在不同线程互不干扰的存储并提供数据，我们就可以通过ThreadLocal存储并获取每个线程的Looper了。需要注意的是除主线程外，其他线程默认是没有Looper的，想要使用Handler就必须为线程创建Looper。

Android消息机制概述

Android的消息机制主要指Handler的运行机制以及Handler附带的MessageQueue和Looper的工作过程。系统之所以提供Handler，就是为了解决在子线程中无法更新UI的矛盾。试想一下，当我们通过网络请求从服务端拉取了一些数据需要更新在UI上，为了避免造成ANR，我们需要在子线程中执行网络请求操作，那该怎么访问UI呢，这时候我们就可以使用Handler，因为它允许我们将一个任务由某个线程切换到另一个线程执行。

延伸

系统为什么不允许在子线程更新UI？

Android的UI控件是线程不安全的，如果在多线程并发访问可能导致UI控件处于不可预期的状态。

为什么不给UI控件的访问加上锁机制？

首先加锁会让UI访问的逻辑变得十分复杂，其次加锁会降低UI的访问效率，因为加锁会阻碍某些线程的执行。

接着概述一下Android的消息机制，首先我们需要创建得到Handler，Handler创建时获取当前线程的Looper来构建内部的消息循环系统（除主线程外都需要手动创建Looper）。Handler创建完毕后，此时内部的Looper和MessageQueue就可以和Handler协调工作了。

Android消息机制分析

ThreadLocal的工作原理

ThreadLocal基础

ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中才可以获取到存储到数据，对于其他线程数据是不可访问的。

当某些数据是以线程为作用域而且不同线程需要不同的数据副本时，就可以考虑使用ThreadLocal。如对于Handler来说，他需要获取当前线程的Looper，因为Looper的作用域是线程且不同线程有不同的Looper，此时我们就可以通过ThreadLocal实现Looper在线程内的存取。

ThreadLocal的另一个使用场景是实现复杂逻辑下的对象传递。比如监听器的传递，有时一个线程中的任务过于复杂——函数调用栈比较深或代码入口多样，我们需要监听器能够贯彻整个线程的执行过程，这时候就可以使用ThreadLocal让监听器作为一个全局变量而存在，在线程内部只需通过get方法获取监听器即可。

上面介绍了这么多理论知识，接下来我们通过一个具体的代码实例来加深理解，在这个实例中我们会创建一个Integer类型的ThreadLocal对象，接着在主线程和三个子线程中分别设置并输出它的值：

//创建ThreadLocal
        ThreadLocal<Integer> booleanThreadLocal=new ThreadLocal<>();
        booleanThreadLocal.set(1);//设置主线程的值为1
        System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());

        //子线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                booleanThreadLocal.set(2);//设置子线程1的值为2
                System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
            }
        }).start();

        //子线程2
        new Thread(new Runnable() {
            @Override
            public void run() {
                booleanThreadLocal.set(3);//设置子线程2的值为3
                System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
            }
        }).start();

        //子线程3
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
            }
        }).start();

打印结果如下：

在这里插入图片描述

可以看到每个线程打印的都是我们设置的值，因为在子线程3我们没有设置值，所以打印的是null。

ThreadLocal之所以能实现上述的效果，是因为不同线程访问同一个ThreadLocal的get方法，ThreadLocal内部会从各自线程中取出一个数组，然后根据当前ThreadLocal的索引去查找对应的value。显然每个线程的数组是不同的，所以通过ThreadLocal可以在指定线程存储数据，其他线程无法访问，不同线程间彼此互不干扰。

ThreadLocal实现原理

想弄清ThreadLocal的实现原理，需要弄清它的set方法和get方法

set方法

这里先介绍一下set方法执行的大概流程，再来介绍一下源码：

1.首先我们会获取当前的线程，然后根据当前的线程获取当前线程的ThreadLocalMap对象（ThreadLocalMap使用一个数组作为存储结构，数组元素为Entry，传入的的ThreadLocal对象作为Entry的key，要存入的值为value）

2.如果获取到了当前线程的ThreadLocalMap对象，那么就将数据存进去

3.如果获取的ThreadLocalMap对象是null，那么就为当前线程创建一个ThreadLocalMap对象

源码分析

打开ThreadLocal的原码找到set方法：

public void set(T value) {
        Thread t = Thread.currentThread();//获取当前线程
        ThreadLocalMap map = getMap(t);//获取当前线程对应的ThreadLocalMap对象
        if (map != null) {
            map.set(this, value);//这里的this就是当前线程的ThreadLocal对象
        } else {
            createMap(t, value);
        }
    }

这个set方法接受一个value参数，这个参数可以指定为任何类型，我们先获取当前线程接着获取当前线程的ThreadLocalMap对象，如果当前线程有ThreadLocalMap对象，那么就将数据直接存进去（存进一个Entry对象，当前线程的ThreadLocal对象作为key，要存储的数据作为value）；如果当前线程没有ThreadLocalMap对象，那么我们就需要去创建一个ThreadLocalMap对象：

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }


private static final int INITIAL_CAPACITY = 16;
private Entry[] table;
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化一个数组
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算key的存储位置
    table[i] = new Entry(firstKey, firstValue);//将数据放到计算出的位置
    size = 1;
    setThreshold(INITIAL_CAPACITY);
    }

可以看到当调用createMap方法后回去创建一个ThreadLocalMap实例，在创建ThreadLocalMap实例时，会初始化一个数组，这个数组就是我们真正用于存取数据的数据结构，这个数组存储数据的数据类型是Entry，也就是一个key-value的数据结构。接着我们会通过传给我们的ThreadLocal参数计算出这个key的储存位置并将数据存到计算出的位置。

小结一下这个过程：我们的每个Thread（线程）都有唯一的一个ThreadLocalMap对象，这个ThreadLocalMap对象使用Enrty[]数组存储数据，Entry[]数组的每个元素都是以当前线程的ThreadLocal对象作为key，要存储的数据作为value的数据结构。

另外提一下使用数组是因为同一线程中可能有多个不同类型的ThreadLocal对象，它们计算出的key是不同的，就对应了在数组上不同的存储位置。

get方法

源码分析

找到get方法

public T get() {
        Thread t = Thread.currentThread();//获取当前线程
        ThreadLocalMap map = getMap(t);//获取当前线程对应的ThreadLocalMap对象
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();//表示当前线程都没有ThreadLocalMap对象或者有ThreadLocalMap对象当不存在ThreadLocal关联的Entry对象，去做一些初始化的工作
    }

同样先获取当前线程再获取当前线程的ThreadLocalMap对象，如果对象不为空，那么就根据key也就是ThreadLocal对象去获取Entry对象，最后获取到的Entry对象不为空时将数据返回，获取Entry对象的方法如下：

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);//计算出存储的位置
    Entry e = table[i];
    if (e != null && e.refersTo(key))
        return e;
    else
        return getEntryAfterMiss(key, i, e);
    }

根据传入的key计算出key的存储位置，这个过程在我们set()方法存储数据时是相对应的，都是根据key（ThreadLocal对象）计算出在数组上的存储位置，接着直接存储位置直接获得Entry对象返回。

通过ThreadLocal的get方法和set方法可以看出，不同线程操作的都是各自线程中的ThreadLocalMap对象的Entry[]数组，所以ThreadLocal可以实现线程间存取数据互不干扰。

MessageQueue

MessageQueue也就是消息队列，虽然它叫做消息队列，但它的实现方法并不是队列，而是使用一个单链表来实现消息列表。

MessageQueue主要有两个方法：enqueueMessage()插入消息和next()读取消息，需要注意的是读取消息时会伴随着消息的删除操作，也就是在读取完这条消息后将其从消息队列中移除。

Looper

Looper在Android消息机制中扮演循环者的角色，它会不停在MessageQueue中查看是否有新消息，如果有新消息就立即处理，否则就一直阻塞在那。在创建Looper时会创建一个MessageQueue对象并获取当前的线程，源码如下：

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

上面我们介绍过，Handler的工作需要Looper，如果一个线程没有Looper对象使用Handler对象就会报错，那么我们怎么获取Looper对象呢，答案是直接调用Looper.prepear()方法即可创建一个Looper对象，然后通过Looper.loop()来开启消息循环，如下：

//子线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                Handler hanlder=new Handler();
                Looper.loop();
            }
        }).start();

Looper也是可以退出的，有quit()和quitSafely()两种方法，使用quit()会直接退出Looper，而quitSafely()会设置一个退出标记，接着把消息队列中已有的消息处理完毕才能安全退出。当Looper退出后，使用Handler的send方法发消息会返回false。

如果我们在子线程中创建了Looper，那么我们就应该在所有事做完之后调用上述两个方法退出Looper。

上面我们还提到了一个loop()方法，只有调用Looper.loop()方法后，消息循环系统才会真正的起作用，我们可以看看它的源码：

打开loop()方法的源码我们可以看到有下面一段代码：

for (;;) {
if (!loopOnce(me, ident, thresholdOverride)) {
return;
}
}

首先我们可以知道loop方法是一个死循环，只有当!loopOnce(me, ident, thresholdOverride条件满足时才会跳出循环，接着我们打开loopOnce方法看看，首先里面有段代码：

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

loop()方法会调用MessageQueue的next()方法一直获取消息，此时一直会处于循环状态。只有当MessageQueue的next()方法返回了null循环才会结束，那么什么情况下MessageQueue的next()方法才会返回null呢。答案是当Looper调用了quit()方法或quitSafely()方法时，我们看看这两个方法：

public void quit() {
   mQueue.quit(false);
}
public void quitSafely() {
   mQueue.quit(true);
}

可以看到Looper的quit()方法和quitSefely()方法这两个方法调用了MessageQueue的quit()方法，我们打开MessageQueue来看看它的quit()方法：

void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }

MessageQueue的quit()方法接收一个布尔型参数用来表示是不是安全的，也就是区分Looper的quit()方法和quitSafely()方法。MessageQueue的quit()方法中有段代码，用来真正进行处理：

if (safe) {//quitSafely()安全退出
removeAllFutureMessagesLocked();
} else {//quit()
removeAllMessagesLocked();
}

点进这两个方法你会发现，这两个方法都是将MessageQueue.next()方法返回的值设为null，这样我们的Looper.quit()和Looper.quitSafely()方法就会执行，Looper退出。

如果MessageQueue的next()方法返回的值不为null，那么就会调用loopOnce()方法里的msg.target.dispatchMessage(msg);方法来处理这条消息，msg.target表示发送这条消息的Handler对象，也就是说Handler发送完消息，这条消息最终又交给Handler的dispatchMessage()方法来处理了，但dispatchMessage()方法是在Looper.loop()方法中执行的。这样我们就可以实现在子线程执行耗时操作，然后在子线程调用Looper.loop()方法执行Handler的dispatchMessage()方法，通知Handler来处理消息，最后到主线程（也就是Handler所在的线程）进行处理消息的操作了。

Handler的工作原理

Handler主要包括消息的发送和接收。发送就是通过post的一系列方法以及send的一系列方法来完成的，其实post的一系列方法最终也是通过send的一系列方法来实现的。

Handler的sendMessage()方法经过层层调用最终会调用到一个enqueueMessage()方法，是不是有点眼熟，在MessageQueue中我们就是通过这个方法插入消息，在Handler的enqueueMessage()方法就是调用MessageQueue.enqueueMessage()方法来向消息队列中添加一条消息，Handler的enqueueMessage()方法如下：

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);//调用MessageQueue的enqueueMessage()方法插入一条消息
    }

当调用Handler的send()方法时，MessageQueue的enqueueMessage()方法执行向消息队列中插入一条消息，同时MessageQueue的next()方法执行将这条消息返回给Looper（Looper通过loop()方法一直在MessageQueue中获取消息），Looper接收到消息就开始处理，最终消息交给Handler处理，即Handler.dispatchMessage()方法被调用，此时Handler进入处理消息阶段，我们可以打开Handler的源码看看dispatchMessage()方法：

public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

这个方法中首先检查Message的callback对象（一个Runnable对象，就是Handler的post()方法传递的Runnable参数），不为空使用handleCallback(msg)方法处理消息。如果没有传递Runnable参数，也就是msg.callback为空，那么就接着判断mCallback是否为空，Callback是一个空接口，其源码定义如下：

public interface Callback {
        /**
         * @param msg A {@link android.os.Message Message} object
         * @return True if no further handling is desired
         */
        boolean handleMessage(@NonNull Message msg);
    }

通常我们在开发过程中，创建Handler的方式是派生一个Handler的子类并重写其handlerMessage()方法来进行具体的消息处理。当我们不想派生子类时，就可以通过Callback这样创建一个Handler对象Handler handler=new Handler(callback)，这样我们就不需要派生Handler的子类。

其实上面代码不是特别重要，重要的是handleMessage(msg)这个方法。Handler的dispatchMessage()方法最终，调用handleMessage()方法来进行具体的消息处理。

总结

最后我们总结一下上面讲到的几个方法的相互之间的调用：

Handler通过sendMessage()方法向MessageQueue中添加Message（MessageQueue的enqueueMessage()方法执行）
Looper通过loop()方法，不停检查MessageQueue中是否有新消息(除非调用了Looper的quit()方法或quitSafely()方法)，有就执行消息（MessageQueue的next()方法执行）
处理消息时Looper调用Handler的dispatchMessage()方法，将消息交给Handler的HandleMessage()方法执行