Android的Looper和Handler消息处理机制详解

AMessage-ALooper-AHandler消息机制流程分析 阅读详情
Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理。
Handler:处理者,负责Message的发送及处理。使用Handler时,需要实现handleMessage(Message msg)方法来对特定的Message进行处理,例如更新UI等。
MessageQueue:消息队列,用来存放Handler发送过来的消息,并按照FIFO规则执行。当然,存放Message并非实际意义的保存,而是将Message以链表的方式串联起来的,等待Looper的抽取。
Looper:消息泵,不断地从MessageQueue中抽取Message执行。因此,一个MessageQueue需要一个Looper。
Thread:线程,负责调度整个消息循环,即消息循环的执行场所。

Android系统的消息队列和消息循环都是针对具体线程的,一个线程可以存在(当然也可以不存在)一个消息队列和一个消 息循环(Looper),特定线程的消息只能分发给本线程,不能进行跨线程,跨进程通讯。但是创建的工作线程默认是没有消息循环和消息队列的,如果想让该 线程具有消息队列和消息循环,需要在线程中首先调用Looper.prepare()来创建消息队列,然后调用Looper.loop()进入消息循环。 如下例所示:

  1. LooperThread Thread {
  2. Handler mHandler;
  3.  
  4. run() {
  5. Looper.prepare();
  6.  
  7. mHandler = Handler() {
  8. handleMessage(Message msg) {
  9.  
  10. }
  11. };
  12.  
  13. Looper.loop();
  14. }
  15. }

 

  1. //Looper类分析
  2. //没找到合适的分析代码的办法,只能这么来了。每个重要行的上面都会加上注释
  3. //功能方面的代码会在代码前加上一段分析
  4. public class Looper {
  5. //static变量,判断是否打印调试信息。
  6. private static final boolean DEBUG = false;
  7. private static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV;
  8. // sThreadLocal.get() will return null unless you've called prepare().
  9. //线程本地存储功能的封装,TLS,thread local storage,什么意思呢?因为存储要么在栈上,例如函数内定义的内部变量。要么在堆上,例如new或者malloc出来的东西
  10. //但是现在的系统比如Linux和windows都提供了线程本地存储空间,也就是这个存储空间是和线程相关的,一个线程内有一个内部存储空间,这样的话我把线程相关的东西就存储到
  11. //这个线程的TLS中,就不用放在堆上而进行同步操作了。
  12. private static final ThreadLocal sThreadLocal = new ThreadLocal();
  13. //消息队列,MessageQueue,看名字就知道是个queue..
  14. final MessageQueue mQueue;
  15. volatile boolean mRun;
  16. //和本looper相关的那个线程,初始化为null
  17. Thread mThread;
  18. private Printer mLogging = null;
  19. //static变量,代表一个UI Process(也可能是service吧,这里默认就是UI)的主线程
  20. private static Looper mMainLooper = null;
  21. /** Initialize the current thread as a looper.
  22. * This gives you a chance to create handlers that then reference
  23. * this looper, before actually starting the loop. Be sure to call
  24. * {@link #loop()} after calling this method, and end it by calling
  25. * {@link #quit()}.
  26. */
  27. //往TLS中设上这个Looper对象的,如果这个线程已经设过了looper的话就会报错
  28. //这说明,一个线程只能设一个looper
  29. public static final void prepare() {
  30. if (sThreadLocal.get() != null) {
  31. throw new RuntimeException("Only one Looper may be created per thread");
  32. }
  33. sThreadLocal.set(new Looper());
  34. }
  35. /** Initialize the current thread as a looper, marking it as an application's main
  36. * looper. The main looper for your application is created by the Android environment,
  37. * so you should never need to call this function yourself.
  38. * {@link #prepare()}
  39. */
  40. //由framework设置的UI程序的主消息循环,注意,这个主消息循环是不会主动退出的
  41. //
  42. public static final void prepareMainLooper() {
  43. prepare();
  44. setMainLooper(myLooper());
  45. //判断主消息循环是否能退出....
  46. //通过quit函数向looper发出退出申请
  47. if (Process.supportsProcesses()) {
  48. myLooper().mQueue.mQuitAllowed = false;
  49. }
  50. }
  51. private synchronized static void setMainLooper(Looper looper) {
  52. mMainLooper = looper;
  53. }
  54. /** Returns the application's main looper, which lives in the main thread of the application.
  55. */
  56. public synchronized static final Looper getMainLooper() {
  57. return mMainLooper;
  58. }
  59. /**
  60. * Run the message queue in this thread. Be sure to call
  61. * {@link #quit()} to end the loop.
  62. */
  63. //消息循环,整个程序就在这里while了。
  64. //这个是static函数喔!
  65. public static final void loop() {
  66. Looper me = myLooper();//从该线程中取出对应的looper对象
  67. MessageQueue queue = me.mQueue;//取消息队列对象...
  68. while (true) {
  69. Message msg = queue.next(); // might block取消息队列中的一个待处理消息..
  70. //if (!me.mRun) {//是否需要退出?mRun是个volatile变量,跨线程同步的,应该是有地方设置它。
  71. // break;
  72. //}
  73. if (msg != null) {
  74. if (msg.target == null) {
  75. // No target is a magic identifier for the quit message.
  76. return;
  77. }
  78. if (me.mLogging!= null) me.mLogging.println(
  79. ">>>>> Dispatching to " + msg.target + " "
  80. + msg.callback + ": " + msg.what
  81. );
  82. msg.target.dispatchMessage(msg);
  83. if (me.mLogging!= null) me.mLogging.println(
  84. "<<<<< Finished to " + msg.target + " "
  85. + msg.callback);
  86. msg.recycle();
  87. }
  88. }
  89. }
  90. /**
  91. * Return the Looper object associated with the current thread. Returns
  92. * null if the calling thread is not associated with a Looper.
  93. */
  94. //返回和线程相关的looper
  95. public static final Looper myLooper() {
  96. return (Looper)sThreadLocal.get();
  97. }
  98.  
  99. /**
  100. * Control logging of messages as they are processed by this Looper. If
  101. * enabled, a log message will be written to printer
  102. * at the beginning and ending of each message dispatch, identifying the
  103. * target Handler and message contents.
  104. *
  105. * @param printer A Printer object that will receive log messages, or
  106. * null to disable message logging.
  107. */
  108. //设置调试输出对象,looper循环的时候会打印相关信息,用来调试用最好了。
  109. public void setMessageLogging(Printer printer) {
  110. mLogging = printer;
  111. }
  112. /**
  113. * Return the {@link MessageQueue} object associated with the current
  114. * thread. This must be called from a thread running a Looper, or a
  115. * NullPointerException will be thrown.
  116. */
  117. public static final MessageQueue myQueue() {
  118. return myLooper().mQueue;
  119. }
  120. //创建一个新的looper对象,
  121. //内部分配一个消息队列,设置mRun为true
  122. private Looper() {
  123. mQueue = new MessageQueue();
  124. mRun = true;
  125. mThread = Thread.currentThread();
  126. }
  127.  
  128. public void quit() {
  129. Message msg = Message.obtain();
  130. // NOTE: By enqueueing directly into the message queue, the
  131. // message is left with a null target. This is how we know it is
  132. // a quit message.
  133. mQueue.enqueueMessage(msg, 0);
  134. }
  135.  
  136. /**
  137. * Return the Thread associated with this Looper.
  138. */
  139. public Thread getThread() {
  140. return mThread;
  141. }
  142. //后面就简单了,打印,异常定义等。
  143. public void dump(Printer pw, String prefix) {
  144. pw.println(prefix + this);
  145. pw.println(prefix + "mRun=" + mRun);
  146. pw.println(prefix + "mThread=" + mThread);
  147. pw.println(prefix + "mQueue=" + ((mQueue != null) ? mQueue : "(null"));
  148. if (mQueue != null) {
  149. synchronized (mQueue) {
  150. Message msg = mQueue.mMessages;
  151. int n = 0;
  152. while (msg != null) {
  153. pw.println(prefix + " Message " + n + ": " + msg);
  154. n++;
  155. msg = msg.next;
  156. }
  157. pw.println(prefix + "(Total messages: " + n + ")");
  158. }
  159. }
  160. }
  161.  
  162. public String toString() {
  163. return "Looper{"
  164. + Integer.toHexString(System.identityHashCode(this))
  165. + "}";
  166. }
  167.  
  168. static class HandlerException extends Exception {
  169.  
  170. HandlerException(Message message, Throwable cause) {
  171. super(createMessage(cause), cause);
  172. }
  173.  
  174. static String createMessage(Throwable cause) {
  175. String causeMsg = cause.getMessage();
  176. if (causeMsg == null) {
  177. causeMsg = cause.toString();
  178. }
  179. return causeMsg;
  180. }
  181. }
  182. }
  183.  
  184. 那怎么往这个消息队列中发送消息呢??调用looper的static函数myQueue可以获得消息队列,这样你就可用自己往里边插入消息了。不过这种方法比较麻烦,这个时候handler类就发挥作用了。先来看看handler的代码,就明白了。
  185. class Handler{
  186. ..........
  187. //handler默认构造函数
  188. public Handler() {
  189. //这个if是干嘛用的暂时还不明白,涉及到java的深层次的内容了应该
  190. if (FIND_POTENTIAL_LEAKS) {
  191. final Class<? extends Handler> klass = getClass();
  192. if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
  193. (klass.getModifiers() & Modifier.STATIC) == 0) {
  194. Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
  195. klass.getCanonicalName());
  196. }
  197. }
  198. //获取本线程的looper对象
  199. //如果本线程还没有设置looper,这回抛异常
  200. mLooper = Looper.myLooper();
  201. if (mLooper == null) {
  202. throw new RuntimeException(
  203. "Can't create handler inside thread that has not called Looper.prepare()");
  204. }
  205. //无耻啊,直接把looper的queue和自己的queue搞成一个了
  206. //这样的话,我通过handler的封装机制加消息的话,就相当于直接加到了looper的消息队列中去了
  207. mQueue = mLooper.mQueue;
  208. mCallback = null;
  209. }
  210. //还有好几种构造函数,一个是带callback的,一个是带looper的
  211. //由外部设置looper
  212. public Handler(Looper looper) {
  213. mLooper = looper;
  214. mQueue = looper.mQueue;
  215. mCallback = null;
  216. }
  217. // 带callback的,一个handler可以设置一个callback。如果有callback的话,
  218. //凡是发到通过这个handler发送的消息,都有callback处理,相当于一个总的集中处理
  219. //待会看dispatchMessage的时候再分析
  220. public Handler(Looper looper, Callback callback) {
  221. mLooper = looper;
  222. mQueue = looper.mQueue;
  223. mCallback = callback;
  224. }
  225. //
  226. //通过handler发送消息
  227. //调用了内部的一个sendMessageDelayed
  228. public final boolean sendMessage(Message msg)
  229. {
  230. return sendMessageDelayed(msg, 0);
  231. }
  232. //FT,又封装了一层,这回是调用sendMessageAtTime了
  233. //因为延时时间是基于当前调用时间的,所以需要获得绝对时间传递给sendMessageAtTime
  234. public final boolean sendMessageDelayed(Message msg, long delayMillis)
  235. {
  236. if (delayMillis < 0) {
  237. delayMillis = 0;
  238. }
  239. return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
  240. }
  241. public boolean sendMessageAtTime(Message msg, long uptimeMillis)
  242. {
  243. boolean sent = false;
  244. MessageQueue queue = mQueue;
  245. if (queue != null) {
  246. //把消息的target设置为自己,然后加入到消息队列中
  247. //对于队列这种数据结构来说,操作比较简单了
  248. msg.target = this;
  249. sent = queue.enqueueMessage(msg, uptimeMillis);
  250. }
  251. else {
  252. RuntimeException e = new RuntimeException(
  253. this + " sendMessageAtTime() called with no mQueue");
  254. Log.w("Looper", e.getMessage(), e);
  255. }
  256. return sent;
  257. }
  258. //还记得looper中的那个消息循环处理吗
  259. //从消息队列中得到一个消息后,会调用它的target的dispatchMesage函数
  260. //message的target已经设置为handler了,所以
  261. //最后会转到handler的msg处理上来
  262. //这里有个处理流程的问题
  263. public void dispatchMessage(Message msg) {
  264. //如果msg本身设置了callback,则直接交给这个callback处理了
  265. if (msg.callback != null) {
  266. handleCallback(msg);
  267. } else {
  268. //如果该handler的callback有的话,则交给这个callback处理了---相当于集中处理
  269. if (mCallback != null) {
  270. if (mCallback.handleMessage(msg)) {
  271. return;
  272. }
  273. }
  274. //否则交给派生处理,基类默认处理是什么都不干
  275. handleMessage(msg);
  276. }
  277. }
  278. ..........
  279. }
  280.  
  281. 生成
  282. Message msg = mHandler.obtainMessage();
  283. msg.what = what;
  284. msg.sendToTarget();
  285.  
  286. 发送
  287. MessageQueue queue = mQueue;
  288. if (queue != null) {
  289. msg.target = this;
  290. sent = queue.enqueueMessage(msg, uptimeMillis);
  291. }
  292.  
  293. 在Handler.java的sendMessageAtTime(Message msg, long uptimeMillis)方法中,我们看到,它找到它所引用的MessageQueue,然后将Message的target设定成自己(目的是为了在处理消息环节,Message能找到正确的Handler),再将这个Message纳入到消息队列中。
  294. 抽取
  295. Looper me = myLooper();
  296. MessageQueue queue = me.mQueue;
  297. while (true) {
  298. Message msg = queue.next(); // might block
  299. if (msg != null) {
  300. if (msg.target == null) {
  301. // No target is a magic identifier for the quit message.
  302. return;
  303. }
  304. msg.target.dispatchMessage(msg);
  305. msg.recycle();
  306. }
  307. }
  308.  
  309. 在Looper.java的loop()函数里,我们看到,这里有一个死循环,不断地从MessageQueue中获取下一个(next方法)Message,然后通过Message中携带的target信息,交由正确的Handler处理(dispatchMessage方法)。
  310. 处理
  311. if (msg.callback != null) {
  312. handleCallback(msg);
  313. } else {
  314. if (mCallback != null) {
  315. if (mCallback.handleMessage(msg)) {
  316. return;
  317. }
  318. }
  319. handleMessage(msg);
  320. }
  321.  
  322. 在Handler.java的dispatchMessage(Message msg)方法里,其中的一个分支就是调用handleMessage方法来处理这条Message,而这也正是我们在职责处描述使用Handler时需要实现handleMessage(Message msg)的原因。
  323. 至于dispatchMessage方法中的另外一个分支,我将会在后面的内容中说明。
  324. 至此,我们看到,一个Message经由Handler的发送,MessageQueue的入队,Looper的抽取,又再一次地回到Handler的怀抱。而绕的这一圈,也正好帮助我们将同步操作变成了异步操作。
  325. 3)剩下的部分,我们将讨论一下Handler所处的线程及更新UI的方式。
  326. 在主线程(UI线程)里,如果创建Handler时不传入Looper对象,那么将直接使用主线程(UI线程)的Looper对象(系统已经帮我们创建了);在其它线程里,如果创建Handler时不传入Looper对象,那么,这个Handler将不能接收处理消息。在这种情况下,通用的作法是:
  327. class LooperThread extends Thread {
  328. public Handler mHandler;
  329. public void run() {
  330. Looper.prepare();
  331. mHandler = new Handler() {
  332. public void handleMessage(Message msg) {
  333. // process incoming messages here
  334. }
  335. };
  336. Looper.loop();
  337. }
  338. }
  339.  
  340. 在创建Handler之前,为该线程准备好一个Looper(Looper.prepare),然后让这个Looper跑起来(Looper.loop),抽取Message,这样,Handler才能正常工作。
  341. 因此,Handler处理消息总是在创建Handler的线程里运行。而我们的消息处理中,不乏更新UI的操作,不正确的线程直接更新UI将引发异常。因此,需要时刻关心Handler在哪个线程里创建的。
  342. 如何更新UI才能不出异常呢?SDK告诉我们,有以下4种方式可以从其它线程访问UI线程:
  343. · Activity.runOnUiThread(Runnable)
  344. · View.post(Runnable)
  345. · View.postDelayed(Runnable, long)
  346. · Handler
  347. 其中,重点说一下的是View.post(Runnable)方法。在post(Runnable action)方法里,View获得当前线程(即UI线程)的Handler,然后将action对象post到Handler里。在Handler里,它将传递过来的action对象包装成一个Message(Message的callback为action),然后将其投入UI线程的消息循环中。在Handler再次处理该Message时,有一条分支(未解释的那条)就是为它所设,直接调用runnable的run方法。而此时,已经路由到UI线程里,因此,我们可以毫无顾虑的来更新UI。
  348. 4) 几点小结
  349. · Handler的处理过程运行在创建Handler的线程里
  350. · 一个Looper对应一个MessageQueue
  351. · 一个线程对应一个Looper
  352. · 一个Looper可以对应多个Handler
  353. · 不确定当前线程时,更新UI时尽量调用post方法

常规波束形成——时域波束形成、频域波束形成 本文介绍了波束成形,包括时域波束成形和频域波束成形,并解释了在实现过程可能存在疑惑的相位补偿。 阅读详情

相关推荐

SIMULIA-Simpack 2022x新功能介绍

增加库伦摩擦类型力元95 Coulomb Friction增加了3种新的摩擦方向类型用于模拟平面、圆柱和球面摩擦。针对平移和旋转摩擦改进了滑动到粘着过渡阶段的检测,增加一个参数定义两种不同的滑移-粘滞过渡模式,即“Unloaded stick stiffness”和“Preload stick with last slip”。新增加124'Applied Load’力元允许用户将力或扭矩作为恒定值或通过激励元素施加到To Marker点上。该力元建模操作方便,效率高。支持线性柔性体装配。

crystalzhan的博客 1049

Android Looper和Handler

Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理。 Handler:处理者,负责Message的发送及处理。使用Handler时,需要实现handleMessage(Message msg)方法来对特定的Message进行处理,例如更新UI等。 MessageQueue:消息队列,用来存放Hand

windownew11的专栏 595

解决Calibre中license的错误

本次解决了Calibre在Cadence 617 virtuoso版本中运行不了的错误,在遇到问题的时候,我也跟你们一样,首先是上网查询为什么运行不了呢?明明我安装了之后里面有Calibre的,我当时也是这样的疑惑,一点Calibre运行LVS的时候,一片空白,然后就出现了license的错误,后来点点点,看看看,搜搜搜,最终解决了这个问题。虚拟机是VMware16版本,cadence617,Calibre是2015版本。旨在记录遇到的实际问题。

yytu231的博客 1万+

Android应用程序消息处理机制(Looper、Handler)分析

Android应用程序是通过消息来驱动的,系统为每一个应用程序维护一个消息队例,应用程序的主线程不断地从这个消息队例中获取消息(Looper),然后对这些消息进行处理(Handler),这样就实现了通过消息来驱动应用程序的执行,本文将详细分析Android应用程序的消息处理机制。 前面我们学习Android应用程序中的Activity启动(Android应用程序启动过程源代码分析和A...

oraclestudy 601

CubeMX配置ADC+DMA避坑实战:如何避免采样过快导致的系统崩溃

本文针对STM32开发中常见的ADC采样过快导致程序卡死问题,提供了基于CubeMX的实战避坑指南。通过分析ADC与DMA协作机制,详解时钟配置、采样时间、DMA缓冲区长度及中断设置等关键步骤,帮助开发者从源头规避系统崩溃风险,实现稳定可靠的数据采集。

weixin_28273593的博客 325

GT911触摸驱动避坑指南:从寄存器读取到多点触控处理的5个关键步骤详解

本文深入解析了GT911触摸驱动开发中的关键步骤与常见问题。从硬件初始化、I2C通信建立,到核心寄存器操作、缓冲区状态管理,再到配置表烧录与多点触控数据解析,提供了详尽的避坑指南。文章结合STM32等平台的实战代码,重点阐述了驱动调试中的时序、中断处理和坐标映射等核心要点,帮助开发者高效实现稳定可靠的多点触控功能。

weixin_29189363的博客 677

Android开发:Handler、Looper、MessageQueue

Android系统主要通过MessageQueue、Looper和Handler三个类来实现Android应用程序的处理消息机制。---参考罗升阳书集 MessageQueue:用来描述消息队列。 Looper:用来创建消息队列,以及进入消息循环。 Handler:用来发送消息和处理消息。//Handler在Android中很常用,或是用来更新UI,或是派发任务给子线程去执行,也可用

AFull的博客 660

数值计算之 插值法(4)切比雪夫零点插值

数值计算之 插值法(4)切比雪夫零点插值前言插值点选取第一类切比雪夫多项式拉格朗日插值多项式的余项切比雪夫零点插值后记 前言 上篇插值法讨论了多项式插值的解,以及龙格现象。本篇将介绍一种在抽取节点时有效降低龙格现象的方法——切比雪夫零点插值。 插值点选取 插值多项式阶数较高时,在取值空间均匀取点,容易出现龙格现象。 即区间边缘的插值结果与原函数差异很大,而区间中央的插值结果相对较好。这表明,高阶多项式插值对区间中央的节点拟合好,而对两端节点拟合效果差。 自然而然会想到,在两端多采样一些节点,在中间少采样一

qq_41035283的博客 1万+

Android C++系列:JNI中的Handler--ALooper

本文回顾了Android 传统Handler机制,以及在JNI中实现Looper和JNI提供的ALooper的使用方式和技巧:使用管道来实现线程通信,并通过自定义通信协议来解决粘包问题。

轻口味的专栏 717

从CORDIC到DDS:手把手拆解《Verilog传奇》第9章的实战项目(附可跑通的代码)

本文详细解析了如何从CORDIC算法到DDS系统的完整实现过程,基于《Verilog传奇》第9章的实战项目,提供了可运行的Verilog代码。内容涵盖CORDIC算法的硬件实现、DDS系统架构设计、完整系统集成与验证,以及实际部署中的性能调优技巧,适合数字IC和FPGA开发者深入学习。

weixin_42623010的博客 417

使用 MATLAB/Simulink 构建一个 光伏-储能联合系统接入10kV配电网 的协同控制仿真模型

本教程详细介绍了基于Simulink的光伏-储能联合系统在配电网中的协同控制仿真方法。主要内容包括:系统结构设计(光伏阵列、储能电池、双向变流器等);建模流程(MPPT控制、BMS系统、PCS矢量控制);核心协同控制策略(功率平滑、削峰填谷、电压支撑的三层控制架构);仿真结果分析方法及性能评估指标。教程提供了从组件建模到系统集成的完整指导,并建议了模型预测控制、微网孤岛运行等进阶方向,帮助开发者掌握智能电网的关键仿真技术。通过该模型可实现可再生能源的高效利用与电网稳定运行的平衡。

amy_mhd的博客 217

Android异步消息处理机制之Handler、Looper、Message

为什么用异步消息处理机制? 因为Android UI线程是线程不安全的,在子线程中更新UI会直接程序崩溃,另外当UI线程需要执行一个比较耗时的操作的话(IO操作,网络通信等),若是执行时间超过5s,程序会直接ANR,为了解决上述问题,可以使用异步消息处理机制Handler,Handler有两大用处: (1) . 在未来的某个时间点执行调度Message或者Runnable对象 (2) . 将执...

小马快跑的博客 1656

APP爬虫:Airtest的使用和爬取实战详解

Airtest是一个跨平台的自动化测试工具,主要用于移动应用和游戏的UI自动化测试。它支持图像识别、触摸操作、文本输入等功能,能够模拟真实用户的操作行为。此外,Airtest还具备强大的日志记录和报告生成功能,方便开发者进行调试和分析。图像识别:通过截图匹配元素,无需依赖 UI 层次结构。跨平台支持:支持 Android、iOS 和 Windows 应用。简单易用:提供 IDE 和脚本录制功能,降低使用门槛。

数据知道的博客 9621

Android消息处理机制 handler looper messagequene

Android消息处理机制 2011-10-28 13:36 2396人阅读 评论(5) 收藏 举报 Google参考了Windows的消息处理机制,在Android系统中实现了一套类似的消息处理机制。学习Android的消息处理机制,有几个概念(类)必须了解: 1.       Message 消息,理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新

Z153041121的专栏 1422

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

android的消息处理机制(Looper,Handler,Message)

一 前言 在正式剖析Handle机制的原理前,我们先来了解一下相关的术语: 通信的同步(Synchronous):只客户端在向服务器发送请求时,必须要等到服务器返回结果,客户端才会继续发送其他的请求。 通信的异步(Asynchronous) : 指客户端在发送请求后,不必等待服务端的回应就可以发送下一个请求。 所谓同步调用,就是在一个函数或方法调用时,没有得到结果之前,该调用就不返回,直到返回结果。异步调用和同步是相对的,在一个异步调用发起后,被调用者立即返回给调用者,但是调用者不能立刻得到结果,被

qq_39431405的博客 920

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Android消息处理机制——Looper,Handler,Message,MessageQueue

题外话: 过去半年都没有

Abel Joo 尘归尘,土归土。 1699

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

Android消息处理机制:源码剖析Handler、Looper,并实现图片异步加载

引言我们在做 Android 开发时,常常需要实现异步加载图片/网页/其他。事实上,要实现异步加载,就需要实现线程间通信,而在 Android 中结合使用 Handler、Looper、Message 能够让不同的线程通信,完成异步任务。虽然 Android 官方为我们提供了 AsyncTask 类来完成异步任务,但这个类存在许多问题,并不好用,而且,AsyncTask 也是通过 Handler 和

追风筝的吃货,汪~ 6451

Android异步消息处理机制:Handler与Looper原理详解

异步消息处理是现代移动开发中的核心架构,通过生产者-消费者模型实现线程间安全通信。其核心组件包括Message(消息载体)、Handler(处理器)、MessageQueue(队列)和Looper(循环器),共同构建了Android的线程通信基础。在UI线程更新等典型场景中,这种机制能有效避免阻塞并保证线程安全。技术实现上采用对象池优化Message创建,通过优先级队列管理消息分发,并支持同步屏障等高级特性。对于开发者而言,理解Handler的内存泄漏防护和消息洪峰处理策略尤为重要,这些优化手段能显著提升应

weixin_30596023的博客 402

安卓消息处理机制(Looper,Handler,Message)

1.前言 android消息处理机制很基础,也很重要。一般耗时操作需要放到子线程中去执行,执行完后,需要把结果反馈给主线程,在主线程中更新ui。比如:在子线程中加载一张网络图片,加载成功后,在主线程中显示图片。那么,子线程怎样把结果反馈给主线程?这就用到了我们今天讲到的消息处理。 2.简要说明...

239

Android 消息处理机制(Looper、Handler、MessageQueue,Message)

Android 消息处理机制估计都被写烂了,但是依然还是要写一下,因为Android应用程序是通过消息来驱动的,Android某种意义上也可以说成是一个以消息驱动的系统,UI、事件、生命周期都和消息处理机制息息相关,并且消息处理机制在整个Android知识体系中也是尤其重要,在太多的源码分析的文章讲得比较繁琐,很多人对整个消息处理机制依然是懵懵懂懂,这篇文...

cpongo5 540

Android 从源码角度分析消息处理机制(Handler,Looper,Message)

Android 从源码角度分析消息处理机制(Handler,Looper,Message)前言在Android中,修改UI的操作必须要放入到主线程中。而我们的网络请求往往是长时操作,需要放入到子线程进行请求。可以通过Handler实现不同线程间的通信。对于如何实现的,网上有很多的教程或博文,也解释的非常清楚,这里不在多叙。但在使用过程中,我们可能会有一些疑问: 为什么可以通过Handler实现不同的

茅屋 1156

android的消息处理机制——Looper,Handler,Message

本文转自http://my.oschina.net/u/1391648/blog/282892   在开始讨论android的消息处理机制前,先来谈谈一些基本相关的术语。   通信的同步(Synchronous):指向客户端发送请求后,必须要在服务端有回应后客户端才继续发送其它的请求,所以这时所有请求将会在服务端得到同步,直到服务端返回请求。   通信的异步(Asynchronous):指客

fdsdvsfjk的博客 425

Android消息处理机制--Looper/Handler/Message

8 消息机制 8.1 消息机制简介 消息机制解决线程间通信! 8.2 Message 常用API 线程间通信的数据单元,通过message进行传递; 创建对象:Message.obtain(what); 封装的数据 int what://消息标志 int arg1; int arg2; Object obj;//保存任意数据类型 8.3 Handler处理器 Han...

牛八少爷的专栏 695
上一篇: 5款备受关注的开源NoSQL数据库
下一篇: eclipse 背景色 推荐
techgfuture
博客等级 码龄12年 4粉丝 10原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值