Android中Handler、MessageQueue、Looper三者的关系然后手写一套自己的Handler

2024-02-28 10:08
文章标签 android 关系 handler 手写 looper 三者 messagequeue 一套

本文主要是介绍Android中Handler、MessageQueue、Looper三者的关系然后手写一套自己的Handler，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Handler、Looper、MessgaeQueue三者的分工：

  • handler 负责发送消息
  • Looper 负责轮询MessageQueue中的消息，并把消息回传给handler
  • MessageQueue 负责存储消息（先进先出）

Handler、Looper、MessgaeQueue三者的引用关系

  • Handler 中有MessageQueue对象、Looper对象
  • Looper 中有MessageQueue对象(和Handler中的是同一个对象)
  • MessageQueue 中有 Message(而Message中有Handler(target属性))

图解三者的关系：

这里写图片描述

现在我们从创建Handler到handlerMessge收到一条消息，对整个过程进行讲解：

一：创建一个Handler，做了哪些操作？Handler handler = new Handler();

public Handler(Callback callback, boolean async) {//省略若干源码...mLooper = Looper.myLooper();if (mLooper == null) {throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");}mQueue = mLooper.mQueue;
}
  • 重要的一个操作Looper.myLooper()获取当前线程绑定的Looper对象,为什么这么说呢？那就要通过Looper的源码来分析了。
  • mLooper.mQueue获取消息队列

二：Looper.myLooper()，获取当前线程绑定的Looper对象

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();public static @Nullable Looper myLooper() {return sThreadLocal.get();
}
  • sThreadLocal：内部维护着一个 ThreadLocalMap（类似HashMap）以key value形式存储
  • key：当前创建Looper对象的线程
  • value：Looper对象
  • 这里获取到Looper对象可能会是个空对象，因为我们要先调用Looper.prepare()对它进行初始化

Looper.prepare()：为当前线程创建一个Looper对象

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));
}
  • sThreadLocal.set(new Looper(quitAllowed))：这里就为我们创建了Looper对象并绑定到当前线程
  • 重点：第一次使用时 必须先调用Looper.prepare()进行初始化

MessageQueue的初始化又在哪里呢？当然是在Looper的构造函数中啦

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

到这里 三个对象的创建都已经完成了，上面说了使用Handler的时候必须先调用Looper.prepare()方法，但是我们平常使用的时候并没有调用它那为什么也是可以的呢？答案当然是：系统为你调用好了、那系统又在哪里调用的呢？

系统在程序启动的时候默认创建了一个线程 也就是主线程（UI线程）:通过查看ActivityThread.java（这个类并不是一个线程只是一个简单的java类）源码中的main()函数，可以看到如下代码：

public static void main(String[] args) {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");SamplingProfilerIntegration.start();CloseGuard.setEnabled(false);//省略若干代码....Process.setArgV0("<pre-initialized>");//初始化我们的主线程Looper.prepareMainLooper();//省略若干代码....if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}//省略若干代码....//进行无限死循环，当然在loop内部都是通过 线程的等待唤醒机制进行死循环的（节约资源）Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited");}

讲到这里相信你已经理解到了这三者的相互关系，重要的操作都是在Looper中；那继续分析最后一步handler.sendMessage(msg)发送一条消息：

handler.sendMessage(msg)
//调用上面这行代码，我们继续跟踪源码，发现最终调用了如下代码
//将消息添加进MessageQueue中，并唤醒Looper.loop()中的等待 把消息取出。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {msg.target = this;if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);
}

到这里Handler的整个工作的过程就一目了然了：

handler发送一条消息——>放入MessageQueue中——>Looper.loop()死循环 取出消息 回传给handler

下面我们在自己创建一个线程中使用Handler，你就可以很清楚的理解上面的Looper了

new Thread(new Runnable() {@Overridepublic void run() {Handler handler = new Handler() {@Overridepublic void handleMessage(Message msg) {}};}
}).start();

这里写图片描述

可以看到：系统抛出了一个RuntimeException 提示需要调用Looper.prepare() 
那对代码改造一下：

new Thread(new Runnable() {@Overridepublic void run() {Looper.prepare();Handler handler = new Handler() {@Overridepublic void handleMessage(Message msg) {}};Looper.loop();}
}).start();

创建好了handler 最后肯定还是要调用Looper.loop()的，不然消息只是放进去了并没有取出。

疑问一：为什么在主线程中系统调用了Looper.loop()对主线程进行死循环，那Activity的生命周期或者其他的UI更新操作是怎么进行的呢？这里还是要继续查看ActivityThread.java这个类的main()函数源码进行解释：

public static void main(String[] args) {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");SamplingProfilerIntegration.start();CloseGuard.setEnabled(false);//省略若干代码....Process.setArgV0("<pre-initialized>");//初始化我们的主线程Looper.prepareMainLooper();//省略若干代码....//获取更新ui操作或者其他操作的handlerif (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}//省略若干代码....//进行无限死循环，当然在loop内部都是通过 线程的等待唤醒机制进行死循环的（节约资源）Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited");}
  1. 从上面源码中可以看到 首先初始化了一个sMainThreadHandlerHandler对象，那这个对象有什么用呢，下面在告诉你。
  2. 初始化完sMainThreadHandler后执行了Looper.loop();对主线程进行死循环
  3. 最后一行代码就比较骚了我的理解大概就是：如果Looper.loop() 退出了死循环，那么主线程就直接奔溃了、那么你的程序也就退出了。所以主线程是从应用启动一直运行到你程序退出的一个线程。
  4. 我们尝试调用如下代码：
 //将主线程退出Looper.getMainLooper().quit();

与我们预想的一模一样 
这里写图片描述

  1. 我们都知道手动创建一个线程，当run函数中的代码执行完毕那么线程就会自动退出的，那我们的主线程是肯定是不可以退出的（上面已经演示过了），所以主线程最后进行了Looper.loop();让线程进入一个死循环这样线程就一直在运行了。

那么问题来了：Activity中的生命周期函数是怎么被调用的呢？

  1. 当然是使用在死循环之前创建的sMainThreadHandler对象了，它是ActivityThread中的一个内部类class H extends Handler{}，Activity的一些生命周期回调函数都是通过这个来进行回调的。我们来查看一下这个H类里的handlerMessage(Message msg)函数
public void handleMessage(Message msg) {switch (msg.what) {case LAUNCH_ACTIVITY: {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");final ActivityClientRecord r = (ActivityClientRecord) msg.obj;r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);} break;case RELAUNCH_ACTIVITY: {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");ActivityClientRecord r = (ActivityClientRecord)msg.obj;handleRelaunchActivity(r);Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);} break;case PAUSE_ACTIVITY: {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");SomeArgs args = (SomeArgs) msg.obj;handlePauseActivity((IBinder) args.arg1, false,(args.argi1 & USER_LEAVING) != 0, args.argi2,(args.argi1 & DONT_REPORT) != 0, args.argi3);maybeSnapshot();Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);} break;case PAUSE_ACTIVITY_FINISHING: {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");SomeArgs args = (SomeArgs) msg.obj;handlePauseActivity((IBinder) args.arg1, true, (args.argi1 & USER_LEAVING) != 0,args.argi2, (args.argi1 & DONT_REPORT) != 0, args.argi3);Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);} break;// 截取了部分代码，感兴趣的可以查看下源码}

总结：主线程进行UI操作都是通过这个sMainThreadHandler 发送消息 通知界面进行相应的操作

疑问二：为什么在子线程发送一条消息，消息就在主线程中了呢？

原因：创建一个Handler的时候 同时也创建好了Looper 创建Looper的时候又创建好了MeessageQueue 这些都是在主线程中创建的(Handler一般都在主线程进行初始化)，这样当你在其他任何线程中发送一条消息的时候，消息都是在MeessageQueue中，Looper循环从MeessageQueue中取出消息在调用msg.target.dispatchMessage(msg);这样消息就回到了创建Handler的地方 也就是主线程中。（如有错误还望指出）

接下来就根据我们上面分析的内容来自己实现一套Handler:

需要创建的主要类：

  1. MyHandler
  2. MyMessage
  3. MyLooper
  4. MyMessageQueue

MyHandler 这里只给出了主要的实现代码，源码中其他的一些代码都已省略

public class MyHandler {/*** 消息拦截*/private MyCallback mCallback;/*** 轮询器*/private MyLooper looper;/*** 消息队列*/private MyMessageQueue queue;public MyHandler() {this(null);}/*** handler 进行初始化* 1.获取当前线程所绑定的Looper对象*/public MyHandler(MyCallback mCallback) {looper = MyLooper.myLooper();if (looper == null) {throw new RuntimeException("如果当前线程未初始化Looper对象，则需要调用Looper.prepare();");}this.mCallback = mCallback;queue = looper.queue;}/*** 处理消息*/public void handleMessage(MyMessage msg) {}/*** 对消息进行分发*/public void dispatchMessage(MyMessage msg) {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}/*** 发送一条消息*/public final boolean sendMessage(MyMessage msg) {//...中间一系列函数调用，最终执行如下重点代码msg.target = this;return queue.enqueueMessage(msg);}/*** 用来拦截handler发送的消息*/public interface MyCallback {boolean handleMessage(MyMessage msg);}
}

MyMessage 消息实体类

public class MyMessage {public int what;public int arg1;public int arg2;public Object obj;public MyHandler target;public MyHandler getTarget() {return target;}public void setTarget(MyHandler target) {this.target = target;}public void sendToTarget() {target.sendMessage(this);}
}

MyLooper 循环取消息

public class MyLooper {/*** ThreadLocal 内部维护着一个 ThreadLocalMap（类似HashMap）以key value形式存储* key:当前创建Looper对象的线程* value: Looper对象*/static final ThreadLocal<MyLooper> sThreadLocal = new ThreadLocal<>();/*** 当前所在线程*/private final Thread mThread;/*** 消息队列*/public final MyMessageQueue queue;/** 初始化MyLooper对象并绑定他所在的线程* 一个线程内部维护着同一个（Handler Looper MessageQueue）*/public static void prepare() {sThreadLocal.set(new MyLooper());}/*** 初始化消息队列*/private MyLooper() {queue = new MyMessageQueue();mThread = Thread.currentThread();}/*** 返回与当前线程关联的Looper对象* 返回null 则线程中没有初始化一个Looper对象*/public static MyLooper myLooper() {return sThreadLocal.get();}public static void loop() {/*** 在Looper 源码 loop 函数中* <p>使用将消息发送回handler* <p>msg.target.dispatchMessage(msg);*/MyLooper looper = myLooper();MyMessageQueue queue = looper.queue;for (; ; ) {MyMessage msg = queue.next();if (msg != null) {msg.target.dispatchMessage(msg);}}}
}

MyMessageQueu 存储消息

public class MyMessageQueue {private int position = 0;/*** 存储消息*/private List<MyMessage> list = new ArrayList<>();/*** 添加一条消息** @return 是否添加成功*/public boolean enqueueMessage(MyMessage msg) {synchronized (this) {//省略落干源码list.add(msg);}return true;}/*** 获取最新的条消息*/public MyMessage next() {synchronized (this) {if (list.size() > 0) {if (position <= list.size() - 1) {MyMessage message = list.get(position);position++;return message;} else {position = 0;list.clear();}}return null;}}
}

这篇关于Android中Handler、MessageQueue、Looper三者的关系然后手写一套自己的Handler的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

Android开发中gradle下载缓慢的问题级解决方法

Android开发中gradle下载缓慢的问题级解决方法

《Android开发中gradle下载缓慢的问题级解决方法》本文介绍了解决Android开发中Gradle下载缓慢问题的几种方法,本文给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧... 目录一、网络环境优化二、Gradle版本与配置优化三、其他优化措施针对android开发中Gradle下载缓慢的问
阅读更多...
python安装whl包并解决依赖关系的实现

python安装whl包并解决依赖关系的实现

《python安装whl包并解决依赖关系的实现》本文主要介绍了python安装whl包并解决依赖关系的实现,文中通过图文示例介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面... 目录一、什么是whl文件？二、我们为什么需要使用whl文件来安装python库？三、我们应该去哪儿下
阅读更多...
Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

《Android悬浮窗开发示例((动态权限请求|前台服务和通知|悬浮窗创建)》本文介绍了Android悬浮窗的实现效果,包括动态权限请求、前台服务和通知的使用,悬浮窗权限需要动态申请并引导... 目录一、悬浮窗 动态权限请求1、动态请求权限2、悬浮窗权限说明3、检查动态权限4、申请动态权限5、权限设置完毕后
阅读更多...
Android里面的Service种类以及启动方式

Android里面的Service种类以及启动方式

《Android里面的Service种类以及启动方式》Android中的Service分为前台服务和后台服务,前台服务需要亮身份牌并显示通知,后台服务则有启动方式选择,包括startService和b... 目录一句话总结：一、Service 的两种类型：1. 前台服务（必须亮身份牌）2. 后台服务（偷偷干
阅读更多...
MYSQL关联关系查询方式

MYSQL关联关系查询方式

《MYSQL关联关系查询方式》文章详细介绍了MySQL中如何使用内连接和左外连接进行表的关联查询,并展示了如何选择列和使用别名,文章还提供了一些关于查询优化的建议,并鼓励读者参考和支持脚本之家... 目录mysql关联关系查询关联关系查询这个查询做了以下几件事MySQL自关联查询总结MYSQL关联关系查询
阅读更多...
Android kotlin语言实现删除文件的解决方案

Android kotlin语言实现删除文件的解决方案

《Androidkotlin语言实现删除文件的解决方案》：本文主要介绍Androidkotlin语言实现删除文件的解决方案,在项目开发过程中,尤其是需要跨平台协作的项目,那么删除用户指定的文件的... 目录一、前言二、适用环境三、模板内容1.权限申请2.Activity中的模板一、前言在项目开发过程中，尤
阅读更多...
Android数据库Room的实际使用过程总结

Android数据库Room的实际使用过程总结

《Android数据库Room的实际使用过程总结》这篇文章主要给大家介绍了关于Android数据库Room的实际使用过程,详细介绍了如何创建实体类、数据访问对象（DAO）和数据库抽象类,需要的朋友可以... 目录前言一、Room的基本使用1.项目配置2.创建实体类（Entity）3.创建数据访问对象（DAO
阅读更多...
Android WebView的加载超时处理方案

Android WebView的加载超时处理方案

《AndroidWebView的加载超时处理方案》在Android开发中,WebView是一个常用的组件,用于在应用中嵌入网页,然而,当网络状况不佳或页面加载过慢时,用户可能会遇到加载超时的问题,本... 目录引言一、WebView加载超时的原因二、加载超时处理方案1. 使用Handler和Timer进行超
阅读更多...
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影
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2