从源码详细分析Handler 原理

2024-06-05 12:08
文章标签 源码 handler 详细分析 原理

本文主要是介绍从源码详细分析Handler 原理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

终于对handler 下手了😂

先来看看源代码，要看Handler源码还是要从构造方法入手。

  @Deprecatedpublic Handler(@Nullable Callback callback) {this(callback, false);}/*** Use the provided {@link Looper} instead of the default one.** @param looper The looper, must not be null.*/public Handler(@NonNull Looper looper) {this(looper, null, false);}/*** Use the provided {@link Looper} instead of the default one and take a callback* interface in which to handle messages.** @param looper The looper, must not be null.* @param callback The callback interface in which to handle messages, or null.*/public Handler(@NonNull Looper looper, @Nullable Callback callback) {this(looper, callback, false);}

默认无参的构造方法已经过时，所以从有参数的构造方法入手，一共三个，这里涉及到一个类

Looper所以简单看下Looper是个什么

Looper 类的源码还是比较简单的，主要就是ThreadLocal,MeesageQueue

其中 ThreadLocal 是静态的。可以理解为一种数据结构。他本身并不存储对象

而是通过set方法吧对象于当前线程关联起来

从下面两个方法可以看t出主要用于Thread对象创建ThreadLocalMap.而这个Thread LocalMap 的

作用就是把当前对象和T 对象用map 关联起来。在Looper 类中调用set 方法就是把 当前线程和Looper 类关联起来。

private static Looper sMainLooper;  // guarded by Looper.class
private static Observer sObserver;

都提供了静态的set方法来供外部调用

  public void set(T value) {Thread t = Thread.currentThread();//当前线程ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);}
    void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);}

MessageQueue 更为简单 ，是用来管理Message的。Message 是个消息队列，是链式的结构。

所以整个Looper类可以理解为构造了一个MessageQueue，并将当前这个包含了MesageQueue的Looper通过ThreadLocal关联到创建Looper 的线程。

另外Looper类中还有一个静态loop()方法，从源码来看这个方法是分发消息的，但这个方法并没有被Handler类使用。而是提供给HandlerThread 等其他类来使用的。（所以很多网上说的Hander 是使用这个方法来从MessageQueue 中取出消息分发是不对的）。

这里可以参看这篇 https://blog.csdn.net/u011578734/article/details/106241075 这个作者详细的从native层解析了Handler的流程。作者提到是用nativeWake方法来实现消息循环的唤醒操作 

/*** Run the message queue in this thread. Be sure to call* {@link #quit()} to end the loop.*/public static void loop() {final Looper me = myLooper();if (me == null) {throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");}if (me.mInLoop) {Slog.w(TAG, "Loop again would have the queued messages be executed"+ " before this one completed.");}me.mInLoop = true;final MessageQueue queue = me.mQueue;// Make sure the identity of this thread is that of the local process,// and keep track of what that identity token actually is.Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();// Allow overriding a threshold with a system prop. e.g.// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'final int thresholdOverride =SystemProperties.getInt("log.looper."+ Process.myUid() + "."+ Thread.currentThread().getName()+ ".slow", 0);boolean slowDeliveryDetected = false;for (;;) {Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}// This must be in a local variable, in case a UI event sets the loggerfinal Printer logging = me.mLogging;if (logging != null) {logging.println(">>>>> Dispatching to " + msg.target + " " +msg.callback + ": " + msg.what);}// Make sure the observer won't change while processing a transaction.final Observer observer = sObserver;final long traceTag = me.mTraceTag;long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;if (thresholdOverride > 0) {slowDispatchThresholdMs = thresholdOverride;slowDeliveryThresholdMs = thresholdOverride;}final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);final boolean needStartTime = logSlowDelivery || logSlowDispatch;final boolean needEndTime = logSlowDispatch;if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {Trace.traceBegin(traceTag, msg.target.getTraceName(msg));}final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;final long dispatchEnd;Object token = null;if (observer != null) {token = observer.messageDispatchStarting();}long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);try {msg.target.dispatchMessage(msg);if (observer != null) {observer.messageDispatched(token, msg);}dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;} catch (Exception exception) {if (observer != null) {observer.dispatchingThrewException(token, msg, exception);}throw exception;} finally {ThreadLocalWorkSource.restore(origWorkSource);if (traceTag != 0) {Trace.traceEnd(traceTag);}}if (logSlowDelivery) {if (slowDeliveryDetected) {if ((dispatchStart - msg.when) <= 10) {Slog.w(TAG, "Drained");slowDeliveryDetected = false;}} else {if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",msg)) {// Once we write a slow delivery log, suppress until the queue drains.slowDeliveryDetected = true;}}}if (logSlowDispatch) {showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);}if (logging != null) {logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);}// Make sure that during the course of dispatching the// identity of the thread wasn't corrupted.final long newIdent = Binder.clearCallingIdentity();if (ident != newIdent) {Log.wtf(TAG, "Thread identity changed from 0x"+ Long.toHexString(ident) + " to 0x"+ Long.toHexString(newIdent) + " while dispatching to "+ msg.target.getClass().getName() + " "+ msg.callback + " what=" + msg.what);}msg.recycleUnchecked();}}
    private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();}

个然后看一下Handler做了什么事情。

从Handler 最常用 send Message方法入手.sendMessage方法调用了 enqueueMessage

而enqueueMessage调用了MessageQueue类的enqueueMessage。所以handler 无论是post 方法还是直接send 最终都是调用enqueueMessage。

最终都是执行的native 方法，只不过异步的方法会初始化message的callback属性。

不过native是如何调用callback的不得而知了。getPostMessge方法初始化了Message的callback 

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

 public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {if (delayMillis < 0) {delayMillis = 0;}return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);}public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {MessageQueue queue = mQueue;if (queue == null) {RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");Log.w("Looper", e.getMessage(), e);return false;}return enqueueMessage(queue, msg, uptimeMillis);}private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,long uptimeMillis) {msg.target = this;//把当前Handler传给Messagemsg.workSourceUid = ThreadLocalWorkSource.getUid();if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);}

看一下这个MessageQueue类的enqueueMessage 。就是判断消息的target不为空，不是异步的，就把当Message对象放到队列的末尾，并调用一个native方法nativeWake。 那么target指向的对象就是调用sendMessage方法的Handler 对 象。也就是Handler对应的Looper的MessageQueue的每一条Message的target都是这个Handler

盲猜一下这个nativeWake方法。应该就是调用Handler 的Callback并且把Message传递给call back了。这里为猜测是一次执行一条循环的取出。

 boolean enqueueMessage(Message msg, long when) {if (msg.target == null) {throw new IllegalArgumentException("Message must have a target.");}synchronized (this) {if (msg.isInUse()) {throw new IllegalStateException(msg + " This message is already in use.");}if (mQuitting) {IllegalStateException e = new IllegalStateException(msg.target + " sending message to a Handler on a dead thread");Log.w(TAG, e.getMessage(), e);msg.recycle();return false;}msg.markInUse();msg.when = when;Message p = mMessages;boolean needWake;if (p == null || when == 0 || when < p.when) {// New head, wake up the event queue if blocked.msg.next = p;mMessages = msg;needWake = mBlocked;} else {// Inserted within the middle of the queue.  Usually we don't have to wake// up the event queue unless there is a barrier at the head of the queue// and the message is the earliest asynchronous message in the queue.needWake = mBlocked && p.target == null && msg.isAsynchronous();Message prev;for (;;) {prev = p;p = p.next;if (p == null || when < p.when) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p; // invariant: p == prev.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true;}

那么如果现在就要自己实现一个类似于handler 的东西。当然就是用于整理思路，并不能真正意义的实现线程的通讯，因为回调方法仍然是在子线程被调用的。虽然能拿到主线程的对象，但是如果要在主线程执行代码，还是要调用runOnUiThread本质上还是使用的Activity 默认创建的Handler。而真正用于线程通讯的方法是native 的。实际的通讯是使用ThreadLocalWorkSource.getUid();方法返回当前执行sendMessage的线程的标识。而回调执行的线程应该是通过ThreadLocal关联到Looper。由于Handler保存了Looper 并且Message的target 是handler。所以能保证回调到创建Handler 的线程（至于怎么回调的，由于是native方法看不到源码）

那么最后就是根据我的理解，写的demo。源码放上来，看下我理解的大致的流程。

（这里后续看了loop方法后有重新模拟了一个demo在另一篇文章，修改的流程是增加了在创建handler的线程中死循环取出消息，简单的用while循环模拟了一下）

class MyHandler (looper: MyLooper,callback: ((MyMessage) -> Unit)?){var mLooper:MyLoopervar mQueue:MyMessageQueuevar callBack: ((MyMessage) -> Unit)? =callbackinit {mLooper=loopermQueue=looper.messageQueue}fun sendMessage(message: MyMessage){message.mHandler=thismQueue.enqueueMessage(message)}
}class MyLooper {var mThread:Threadcompanion object{var threadLocal =ThreadLocal<MyLooper>()fun myLooper():MyLooper{return threadLocal.get()}}var messageQueue: MyMessageQueueconstructor(){Log.e("threadLooper",Thread.currentThread().name)threadLocal.set(this)mThread= Thread.currentThread()messageQueue=MyMessageQueue(true)}}
class MyMessage {var what:Int=-1var next:MyMessage?=nullvar mHandler: MyHandler?=nullvar workSourceUid:String?=null
}class MyMessageQueue(isAllowQuit: Boolean) {var isAllowQuit:Boolean=isAllowQuitprivate var mMessage: MyMessage?=nullfun enqueueMessage(message: MyMessage){var isNeekWake=falseif(mMessage==null){isNeekWake=truemMessage=message}else {message.mHandler?.let {var temp: MyMessage = mMessage!!while (true) {if (temp.next == null){temp.next=messagebreak}else{temp = temp.next!!}}}}if(isNeekWake){wake()}}fun quitAll(){if(isAllowQuit){while(true){var temp:MyMessage?=mMessageif(temp!=null){mMessage=temp.nexttemp=null}else{break}}mMessage=null}}fun wake(){mMessage?.mHandler?.let {handler->handler.callBack?.let {callback->mMessage?.let {message->Log.e("thread",handler.mLooper.mThread.name)handler.mLooper.mThread//创建handler的线程对象callback（message）message.next?.let{mMessage=itwake()}}}}}
}

调用的部分，并不能真正的在UI 线程执行，只能回调UI 线程的代码 

class MainModel(binding: ActivityMainBinding, context: Activity) :MyBaseModel<ActivityMainBinding>(binding, context) {var handler:MyHandler?=nullinit {bindListener(binding.tvHello)handler= MyHandler(MyLooper(),{myMessage ->Log.e("threada",Thread.currentThread().name)//子线程
////这里要执行在主线程还是需要runOnUiThread(Runnable{})})}override fun onClick(v: View?) {v?.let {when(v.id){R.id.tv_hello->{Thread(Runnable {var message= MyMessage()message.what=33handler?.sendMessage(message)}).start()}else->{}}}}
}

这篇关于从源码详细分析Handler 原理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

目录 前言1. 注解用法1.1 方法参数1.2 方法1.3 类 2. 注解场景2.1 表单参数2.2 AJAX请求2.3 文件上传 3. 实战4. 总结 前言 将请求参数绑定到模型对象上，或者在请求处理之前添加模型属性 可以在方法参数、方法或者类上使用 一般适用这几种场景： 表单处理：通过 @ModelAttribute 将表单数据绑定到模型对象上预处理逻辑：在请求处理之前
阅读更多...
SpringBoot集成Netty，Handler中@Autowired注解为空

SpringBoot集成Netty，Handler中@Autowired注解为空

最近建了个技术交流群，然后好多小伙伴都问关于Netty的问题，尤其今天的问题最特殊，功能大概是要在Netty接收消息时把数据写入数据库，那个小伙伴用的是 Spring Boot + MyBatis + Netty，所以就碰到了Handler中@Autowired注解为空的问题 参考了一些大神的博文，Spring Boot非controller使用@Autowired注解注入为null的问题，得到
阅读更多...
springboot家政服务管理平台 LW +PPT+源码+讲解

springboot家政服务管理平台 LW +PPT+源码+讲解

3系统的可行性研究及需求分析 3.1可行性研究 3.1.1技术可行性分析 经过大学四年的学习，已经掌握了JAVA、Mysql数据库等方面的编程技巧和方法，对于这些技术该有的软硬件配置也是齐全的，能够满足开发的需要。 本家政服务管理平台采用的是Mysql作为数据库，可以绝对地保证用户数据的安全；可以与Mysql数据库进行无缝连接。 所以，家政服务管理平台在技术上是可以实施的。 3.1
阅读更多...
高仿精仿愤怒的小鸟android版游戏源码

高仿精仿愤怒的小鸟android版游戏源码

这是一款很完美的高仿精仿愤怒的小鸟android版游戏源码，大家可以研究一下吧、 为了报复偷走鸟蛋的肥猪们，鸟儿以自己的身体为武器，仿佛炮弹一样去攻击肥猪们的堡垒。游戏是十分卡通的2D画面，看着愤怒的红色小鸟，奋不顾身的往绿色的肥猪的堡垒砸去，那种奇妙的感觉还真是令人感到很欢乐。而游戏的配乐同样充满了欢乐的感觉，轻松的节奏，欢快的风格。 源码下载
阅读更多...
基于Java医院药品交易系统详细设计和实现(源码+LW+调试文档+讲解等)

基于Java医院药品交易系统详细设计和实现(源码+LW+调试文档+讲解等)

💗博主介绍：✌全网粉丝10W+,CSDN作者、博客专家、全栈领域优质创作者，博客之星、平台优质作者、专注于Java、小程序技术领域和毕业项目实战✌💗 🌟文末获取源码+数据库🌟 感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人  Java精品实战案例《600套》 2023-2025年最值得选择的Java毕业设计选题大全：1000个热
阅读更多...
数据库原理与安全复习笔记（未完待续）

数据库原理与安全复习笔记（未完待续）

1 概念 产生与发展：人工管理阶段 → \to → 文件系统阶段 → \to → 数据库系统阶段。 数据库系统特点：数据的管理者（DBMS）；数据结构化；数据共享性高，冗余度低，易于扩充；数据独立性高。DBMS 对数据的控制功能：数据的安全性保护；数据的完整性检查；并发控制；数据库恢复。 数据库技术研究领域：数据库管理系统软件的研发；数据库设计；数据库理论。数据模型要素 数据结构：描述数据库
阅读更多...
计算机组成原理——RECORD

计算机组成原理——RECORD

第一章 概论 1.固件  将部分操作系统固化——即把软件永恒存于只读存储器中。 2.多级层次结构的计算机系统 3.冯*诺依曼计算机的特点 4.现代计算机的组成：CPU、I/O设备、主存储器（MM） 5.细化的计算机组成框图 6.指令操作的三个阶段：取指、分析、执行 第二章 计算机的发展 1.第一台由电子管组成的电子数字积分和计算机（ENIAC） 第三章 系统总线
阅读更多...
美容美发店营销版微信小程序源码

美容美发店营销版微信小程序源码

打造线上生意新篇章 一、引言：微信小程序，开启美容美发行业新纪元 在数字化时代，微信小程序以其便捷、高效的特点，成为了美容美发行业营销的新宠。本文将带您深入了解美容美发营销微信小程序，探讨其独特优势及如何助力商家实现业务增长。 二、微信小程序：美容美发行业的得力助手 拓宽客源渠道：微信小程序基于微信社交平台，轻松实现线上线下融合，帮助商家快速吸引潜在客户，拓宽客源渠道。 提升用户体验：
阅读更多...
风水研究会官网源码系统-可展示自己的领域内容-商品售卖等

风水研究会官网源码系统-可展示自己的领域内容-商品售卖等

一款用于展示风水行业，周易测算行业，玄学行业的系统，并支持售卖自己的商品。 整洁大气，非常漂亮，前端内容均可通过后台修改。 大致功能： 支持前端内容通过后端自定义支持开启关闭会员功能，会员等级设置支持对接官方支付支持添加商品类支持添加虚拟下载类支持自定义其他类型字段支持生成虚拟激活卡支持采集其他站点文章支持对接收益广告支持文章评论支持积分功能支持推广功能更多功能，搭建完成自行体验吧！ 原文
阅读更多...
GaussDB关键技术原理：高性能（二）

GaussDB关键技术原理：高性能（二）

GaussDB关键技术原理：高性能（一）从数据库性能优化系统概述对GaussDB的高性能技术进行了解读，本篇将从查询处理综述方面继续分享GaussDB的高性能技术的精彩内容。 2 查询处理综述 内容概要：本章节介绍查询端到端处理的执行流程，首先让读者对查询在数据库内部如何执行有一个初步的认识，充分理解查询处理各阶段主要瓶颈点以及对应的解决方案，本章以GaussDB为例讲解查询执行的几个主要阶段
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2