Android Handler消息机制完全解析(二)

2024-08-31 15:52
文章标签 android 解析 消息 完全 机制 handler

本文主要是介绍Android Handler消息机制完全解析(二)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

欢迎转载，转载请注明出处：https://blog.csdn.net/dmk877/article/details/141690289

在阅读本篇博客之前建议先阅读此篇 Android Handler消息机制完全解析(一)

在看Looper源码之前必须要理解ThreadLocal，ThreadLocal在Handler消息机制中起到了至关重要的作用，面试中也经常会被问到，所以我们先来了解下ThreadLocal，通过本篇博客你将学到

①ThreadLocal的作用以及原理

②Looper方法的源码

③Handler的dispatchMessage消息分发流程

④几个常见的面试题

1.ThreadLocal的作用

ThreadLocal主要有以下作用

(1)线程隔离:每个线程都可以独立的改变自己的副本，而不会影响其它线程的副本

(2)减少同步:由于每个线程操作的是属于自己的数据副本，因此可以避免使用同步机制(synchronized或Lock)来保护共享数据，从而提高性能

(3)简化编程：在某些情况下，使用 ThreadLocal 可以使代码更加简洁，因为它允许开发者以单线程的方式来编写多线程代码。

看到这你可能有点懵，看段代码你就会理解

static ThreadLocal<String> localVar = new ThreadLocal<String>();public static void main(String[] args) {localVar.set("main");Thread thread1 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("thread1 localVar:" + localVar.get());localVar.set("thread1");System.out.println("thread1 localVar: " + localVar.get());}});Thread thread2 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("thread2 localVar:" + localVar.get());localVar.set("thread2");System.out.println("thread2 localVar: " + localVar.get());}});thread1.start();thread2.start();System.out.println(localVar.get());
}

输出

main
thread1 localVar:null
thread2 localVar:null
thread1 localVar: thread1
thread2 localVar: thread2

上述代码中在主线程中声明了一个ThreadLocal变量，然后分别在主线程和两个子线程中set值并取出进行打印，你会发现ThreadLocal变量在主线程中设置值后在子线程thread1和thread1中get获取时是null,main、thread1、thread2对localVar 的操作互不影响，对，这就是线程隔离，实现的原理就是每个线程中都会保存一个ThreadLocal的副本，每次在子线程中修改只是修改了当前线程对应的ThreadLocal对象，对其它线程没有影响。那么问题来了，它是怎么做到的呢？

2.ThreadLocal源码解析

在详细查看源码前，先来看下实现原理图，大概了解之后再看源码事半功倍

在这里插入图片描述

从图中可以看到每一个Thread都会持有一个ThreadLocalMap对象，这个ThreadLocalMap内部持有一个Entry类型的数组，Entry类型有key和value键值对其中key就是ThreadLocal对象，value就是每个线程需要隔离的变量。这样就实现了数据与线程的隔离，每个线程有自己独立的数据。另外需要说明的是一个ThreadLocal实例，在一个线程中只能存储一类数据，线程中的ThreadLocalMap是一个数组结构它可以存储多个ThreadLocal对象。有点懵？没关系，接下来我们看源码，源码结合上图相信你能很好的理解其中的奥妙。

首先从ThreadLocal的set方法开始

public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);
}ThreadLocalMap getMap(Thread t) {return t.threadLocals;
}public class Thread implements Runnable {....../* ThreadLocal values pertaining to this thread. This map is maintained* by the ThreadLocal class. */ThreadLocal.ThreadLocalMap threadLocals = null;......
}

在ThreadLocal的set方法中首先获取当前的线程对象t，然后以t为参数调用getMap方法，getMap返回的其实就是当前线程对应的threadLocals，它是声明在Thread类中的ThreadLocal.ThreadLocalMap对象，ThreadLocalMap是ThreadLocal的静态内部类

static class ThreadLocalMap {static class Entry extends WeakReference<ThreadLocal<?>> {/** The value associated with this ThreadLocal. */Object value;Entry(ThreadLocal<?> k, Object v) {super(k);value = v;}}private static final int INITIAL_CAPACITY = 16;private Entry[] table;private void set(ThreadLocal<?> key, Object value) {......tab[i] = new Entry(key, value);......}
}

可以看到ThreadLocalMap中有一个Entry类型的数组，ThreadLocalMap的set方法的参数key就是ThreadLocal类型的参数，value就是我们要保存的数据

如下图所示

在这里插入图片描述

这就是set的大致流程，还是比较清晰的。接下来看看ThreadLocal的get方法源码

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

同样也是先获取当前所在线程t，然后以t为参数调用getMap方法获取与当前线程对应的ThreadLocalMap对象，然后调用map.getEntry(this)在set的时候说过，ThreadLocalMap.Entry中key是ThreadLocalMap对象，value就是我们要保存的值，这里也是将this传入然后拿到当前ThreadLocal对象中保存的值然后返回。到这里大家应该能很清楚的知道ThreadLocal是怎么实现线程隔离的了。其实就是每个线程独有一个ThreadLocalMap对象，当我们set值时会先获取当前的线程，然后得到当前线程的ThreadLocalMap对象，然后将我们要保存的数据存放到ThreadLocalMap中的Entry数组中，get值也是先获取ThreadLocalMap对象，然后根据key(当前的ThreadLocal对象)获取到我们保存的数据。

ok，了解ThreadLocal对Looper的源码会有很大的帮助，接下来我们就来分析下Handler机制中的Looper

3.Looper源码分析

Looper是Handler的核心组成部分之一，它是一个消息循环器，负责管理消息队列，每个线程都可以创建自己的Looper主线程默认就会创建一个Looper，Looper通过Looper.prepare()进行初始化，然后调用Looper.loop()开启消息循环，接下来我们看下Looper的核心代码

public final class Looper {......// 保存当前线程的Looper对象,注意这个ThreadLocal对象保存是一个Looper对象，每个线程的Looper是独立的static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal();// 主线程Looperprivate static Looper sMainLooper;// 当前线程的MessageQueue对象final MessageQueue mQueue;// 创建Looper的线程final Thread mThread;......public static Looper myLooper() {// 返回当前线程的looperreturn (Looper)sThreadLocal.get();}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");} else {sThreadLocal.set(new Looper(quitAllowed));}}......
}
  • myLooper方法

首先看myLooper方法其实就是获取当前线程的looper对象，它是保存在ThreadLocal对象中的从刚才对ThreadLocal的讲解这一点应该很好理解。

  • prepare方法

prepare方法会调用prepare(boolean)方法，在prepare(quitAllowed)方法中会判断looper是否为空，如果不为空则会抛异常Only one Looper may be created per thread，这也是面试中经常被问到的，这也就是说一个线程只能创建一个Looper对象，否则会抛异常。

再看下Looper的构造方法

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

因为在Looper的prepare方法中会往ThreadLocal对象中set Looper对象即调用sThreadLocal.set(new Looper(quitAllowed))，而MessageQueue又是在Looper的构造函数中创建的因此一个线程只有一个Looper对象，同时也只有一个MessageQueue对象。

还有一个重要方法loop

public static void loop() {final Looper me = myLooper();......final MessageQueue queue = me.mQueue;for (;;) {// 不停的从MessageQueue中取消息，当没消息时可能会阻塞Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}msg.target.dispatchMessage(msg);// 将消息进行回收放到消息池中，以便后续使用msg.recycleUnchecked();}}

为了更好的阅读我删除很多代码，只留下了最核心的代码，从loop的源码中可以看到调用loop方法后会开启一个死循环，这就相当于我们给传送带通电，此时它就获得了动力，在这个死循环里会不停的调用MessageQueue的next方法向MessageQueue中取消息，取到消息之后就会调用msg.target.dispatchMessage方法

4. Handler dispatchMessage消息分发流程

在上一篇中我们说到在MessageQueue的enqueueMessage方法中会将当前的handler赋值给msg.target因此这里的msg.target就是Handler对象，那我们来看下源码就看下Handler的dispatchMessage方法的源码

public void dispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (this.mCallback != null && this.mCallback.handleMessage(msg)) {return;}this.handleMessage(msg);}
}private static void handleCallback(Message message) {message.callback.run();
}

考点来了，在上一篇文章的开头，我列举了几个大厂的面试题其中就有

Handler的callback存在但返回true,handleMessage是否会执行？看到这个问题是不是有点懵？没关系带着这个问题分析完dispatchMessage这个方法之后你就会非常清晰，这里面有两个callback一个是msg.callback一个是this.mCallback我们一个一个来看首先来看

  • msg.callbak

这个callback是从哪里来的呢？在上一篇文章中也提到Handler发送消息有两种方法一种是调用handler.send，一种是调用handler.post，再看下Handler的post方法的源码如下

public final boolean post(Runnable r) {return this.sendMessageDelayed(getPostMessage(r), 0L);
}private static Message getPostMessage(Runnable r) {Message m = Message.obtain();m.callback = r;return m;
}

可以看到在调用Handler的post方法时它传递的参数是一个Runnable对象，并且将这个Runnable对象转化为Messgage对象后调用send方法发出去，在转化的过程中有一个赋值m.callback=r即将当前的Runnable对象赋值个Message的callback，这就是msg.callback，也就是说只有调用handler.post方法时msg.callback才不为空。

  • this.mCallback

this.mCallback很明显是Handler的变量，它是怎么来的呢？它是通过new Handler时传递过来的，如下所示

在这里插入图片描述

public Handler(Looper looper, Handler.Callback callback, boolean async) {this.mLooper = looper;this.mQueue = looper.mQueue;this.mCallback = callback;this.mAsynchronous = async;
}public interface Callback {boolean handleMessage(Message var1);
}

注意区分Handler.callback.handleMessage和this.handleMessage

  • this.handleMessage(msg)

这个就是我们重写的Handler的handleMessage方法

理清楚这些，再来个实例你肯定就会非常清楚,看个实例代码

mHandler = new Handler(getMainLooper(), new Handler.Callback() {@Overridepublic boolean handleMessage(@NonNull Message msg) {Log.d(TAG, "Handler.Callback handleMessage is called");return true;}
}) {@Overridepublic void handleMessage(@NonNull Message msg) {Log.d(TAG, "Handler handleMessage is called");super.handleMessage(msg);}
};handlerPost.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {mHandler.post(new Runnable() {@Overridepublic void run() {Log.d(TAG, "handler post onClick,send post msg");}});}
});handlerSend.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Log.d(TAG, "handler send onClick,send msg");Message msg = Message.obtain();mHandler.sendMessage(msg);}
});

可以看到在new Handler的时候传递了Handler.callback参数并且返回true，并且重写了Handler的handleMessage方法然后定义了两个按钮一个用来调用Handler的post方法，一个用来调用Handler的send方法,点击handlerPost打印结果

MainActivity: handler post onClick,send post msg

分析：根据Handler的dispatchMessage如果msg.callack!=null则直接调用handleCallback(msg)方法，handleCallback方法其实就是调用msg.callback.run()，此时就会执行hander.post(runnable)中的runnable任务，因此就是只打印了handler post onClick,send post msg。

点击handlerSend打印结果

MainActivity: handler send onClick,send msg
MainActivity: Handler.Callback handleMessage is called

这个就有点说法了,再看下dispatchMessage的代码

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

首先第一个if不满足，send方法发送的消息msg.callback==null，进入else,因为我们在new Handler的时候传递了Handler.callback回调，所以this.callback!=null成立，而我们传递的回调中Handler.callback返回true因此执行this.mCallback.handleMessage它也返回了true，两个条件成立因此直接return,this.handleMessage不会执行到，在上述代码中做下修改把Handler.callback的返回值改为false打印结果是啥呢？大家可以自己尝试下。

因此Handler的callback存在但返回true,handleMessage是否会执行？的回答是不会执行。另外此处还涉及到一个面试题

面试题：Handler的post和send方法的区别，相信到此你也能回答出来，主要从发送和分发来回答

（1）post一类的方法发送的是Runnable对象，但是最后还是会被封装成Message对象，将Runnable对象赋值给Message对象中的callback字段，然后交由sendMessageAtTime()方法发送出去。

在处理消息时，会在dispatchMessage()方法里首先被handleCallback(msg)方法执行，实际上就是执行Message对象里面的Runnable对象的run方法。

（2）sendMessage一类方法发送的消息直接是Message对象，处理消息时，在dispatchMessage里优先级会低于handleCallback(msg)方法，是通过自己重写的handleMessage(msg)方法执行。

5. 子线程中如何正确创建Handler

好，到这里Handler相关的几个对象Handler、MessageQueue、Looper就介绍的差不多了，到这里可能有些同学还是心存疑惑，到底这个Handler机制是从哪里触发的？这里涉及到App的启动流程后面有时间的话会写一篇博客，在这里你只要知道，当我们的手指点击手机上的应用图标时，系统会创建一个ActivityThread负责管理所有Activity的线程，它负责处理Activity的生命周期、事件分发、消息处理等工作，在ActivityThread的main方法源码如下

public static void main(String[] args) {......Looper.prepareMainLooper();ActivityThread thread = new ActivityThread();thread.attach(false, startSeq);if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}// 开启死循环，不停的取消息Looper.loop();
}

也就是说当我们手指点击应用图标应用启动的时候，系统会执行ActivityThread的main方法而在main方法中会调用

Looper.prepareMainLooper()和Looper.loop()

public static void prepareMainLooper() {prepare(false);synchronized (Looper.class) {if (sMainLooper != null) {throw new IllegalStateException("The main Looper has already been prepared.");}sMainLooper = myLooper();}
}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的ThreadLocal对象并调用loop方法开启循环从MessageQueue中取消息，这样整个流程就通了，因为loop是一个死循环，所以当我们使用handler发送一条消息时，在loop方法中会把此消息取出，并调用Handler的dispatchMessage方法将此消息分发出去，执行对应的方法。注意这只针对主线程，在子线程中我们要手动调用Looper.prepare和Looper.loop，如下所示先把Looper.prepare注释掉运行看下下效果

new Thread(new Runnable() {@Overridepublic void run() {// Looper.prepare();mHandler = new Handler(){@Overridepublic void handleMessage(@NonNull Message msg) {super.handleMessage(msg);Log.d(TAG, "mHandler handleMessage is called:" + Thread.currentThread().getName());}};mHandler.sendMessage(Message.obtain());Looper.loop();}
}).start();

在这里插入图片描述
这个报错是不是很常见，很多人都知道调用下Looper.prepare就行了，为什么会报这个错呢？这是因为new Handler的时候会判断当前Handler所在的线程的Looper是否为空？如果为空就抛异常，所以在子线程中不调用Looper.prepare()直接new Handler就会抛异常，源码如下

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

看到没异常就是从这里抛出来的。

这篇就写到这里了，总结下：
(1) Handler是怎么进行线程间通讯的，原理是什么？
Handler之所以能够进行线程间通讯原理就是，线程间内存共享，在Handler机制中共享的就是MessageQueue，首先new Handler的这个线程中的Looper(ThreadLocal使得Looper被当前线程独有)、MessageQueue是与当前线程绑定的，其它的线程拿到这个Handler的引用发送消息时，会将此消息插入到这个MessageQueue中，从而就实现了两个不同线程间的通讯。就是说现在有两个线程A和B，在B中创建了Handler，此时Looper、MessageQueue都在线程B中，在线程A中拿到Handler的引用发送消息时这条消息就会被插入到线程B的MessageQueue中，这样就完成了从线程A到线程B的通讯。这一块建议大家好好理一下。

public Handler handler;
Thread A = new Thread(new Runnable() {@Overridepublic void run() {// handler在线程B中初始化,此消息会插入到线程B中的MessageQueue中handler.sendMessage(Message.obtain());}
});Thread B = new Thread(new Runnable() {@Overridepublic void run() {Looper.prepare();handler = new Handler(){@Overridepublic void handleMessage(@NonNull Message msg) {super.handleMessage(msg);Log.d(TAG, "receive message");}};Looper.loop();}
});B.start();
Thread.sleep(1000);
A.start();

(2)一个线程只有一个Looper并且只有一个MessageQueue
(3)对Handler的dispatchMessge方法的流程要掌握清晰

如果本篇对你有帮助欢迎点赞留言，若发现文中的错误欢迎批评指正，大家一起进步。

这篇关于Android Handler消息机制完全解析(二)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1124340。

相关文章

网页解析 lxml 库--实战

网页解析 lxml 库--实战

lxml库使用流程 lxml 是 Python 的第三方解析库，完全使用 Python 语言编写，它对 XPath表达式提供了良好的支 持，因此能够了高效地解析 HTML/XML 文档。本节讲解如何通过 lxml 库解析 HTML 文档。 pip install lxml lxm| 库提供了一个 etree 模块，该模块专门用来解析 HTML/XML 文档，下面来介绍一下 lxml 库
阅读更多...
JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

技术背景 好多开发者需要遴选Android平台RTSP直播播放器的时候，不知道如何选的好，本文针对常用的方案，做个大概的说明： 1. 使用VLC for Android VLC Media Player（VLC多媒体播放器），最初命名为VideoLAN客户端，是VideoLAN品牌产品，是VideoLAN计划的多媒体播放器。它支持众多音频与视频解码器及文件格式，并支持DVD影音光盘，VCD影
阅读更多...
Java ArrayList扩容机制 （源码解读）

Java ArrayList扩容机制 （源码解读）

结论：初始长度为10，若所需长度小于1.5倍原长度，则按照1.5倍扩容。若不够用则按照所需长度扩容。 一. 明确类内部重要变量含义         1：数组默认长度         2:这是一个共享的空数组实例，用于明确创建长度为0时的ArrayList ，比如通过 new ArrayList<>(0)，ArrayList 内部的数组 elementData 会指向这个 EMPTY_EL
阅读更多...
HDU 2159 二维完全背包

HDU 2159 二维完全背包

FATE 最近xhd正在玩一款叫做FATE的游戏，为了得到极品装备，xhd在不停的杀怪做任务。久而久之xhd开始对杀怪产生的厌恶感，但又不得不通过杀怪来升完这最后一级。现在的问题是，xhd升掉最后一级还需n的经验值，xhd还留有m的忍耐度，每杀一个怪xhd会得到相应的经验，并减掉相应的忍耐度。当忍耐度降到0或者0以下时，xhd就不会玩这游戏。xhd还说了他最多只杀s只怪。请问他能
阅读更多...
zoj 1721 判断2条线段（完全）相交

zoj 1721 判断2条线段（完全）相交

给出起点，终点，与一些障碍线段。 求起点到终点的最短路。 枚举2点的距离，然后最短路。 2点可达条件：没有线段与这2点所构成的线段（完全）相交。 const double eps = 1e-8 ;double add(double x , double y){if(fabs(x+y) < eps*(fabs(x) + fabs(y))) return 0 ;return x + y ;
阅读更多...
android-opencv-jni

android-opencv-jni

//------------------start opencv--------------------@Override public void onResume(){ super.onResume(); //通过OpenCV引擎服务加载并初始化OpenCV类库，所谓OpenCV引擎服务即是 //OpenCV_2.4.3.2_Manager_2.4_*.apk程序包，存
阅读更多...
【编程底层思考】垃圾收集机制，GC算法，垃圾收集器类型概述

【编程底层思考】垃圾收集机制，GC算法，垃圾收集器类型概述

Java的垃圾收集（Garbage Collection，GC）机制是Java语言的一大特色，它负责自动管理内存的回收，释放不再使用的对象所占用的内存。以下是对Java垃圾收集机制的详细介绍： 一、垃圾收集机制概述： 对象存活判断：垃圾收集器定期检查堆内存中的对象，判断哪些对象是“垃圾”，即不再被任何引用链直接或间接引用的对象。内存回收：将判断为垃圾的对象占用的内存进行回收，以便重新使用。
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2