关于android的UI更新机制与误区

Android系统的消息队列和消息循环都是主线程的，其它后台服务等无法直接更新，必须通过下面的消息队列，由主线程的消息循环去依次执行更新ui；

同时对于费时间超过5秒的事件，比如网络链接等，建议新开线程处理，否则系统会提示用户终止你。

扩招知识：

Android系统的消息队列和消息循环都是针对具体线程的，一个线程可以存在（当然也可以不存在）一个消息队列（Message Queue）和一个消息循环（Looper）。Android中除了UI线程（主线程），创建的工作线程默认是没有消息循环和消息队列的。如果想让该线程具有消息队列和消息循环，并具有消息处理机制，就需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。如以下代码所示：

Java代码

  1. class LooperThread extends Thread {
  2. public Handler mHandler;
  3. public void run() {
  4. Looper.prepare();
  5. mHandler = new Handler() {
  6. public void handleMessage(Message msg) {
  7. // process incoming messages here
  8. }
  9. };
  10. Looper.loop();
  11. }
  12. }
  1. class LooperThread extends Thread {
  2. public Handler mHandler;
  3. public void run() {
  4. Looper.prepare();
  5. mHandler = new Handler() {
  6. public void handleMessage(Message msg) {
  7. // process incoming messages here
  8. }
  9. };
  10. Looper.loop();
  11. }
  12. }

这样该线程就具有了消息处理机制了。如果不调用Looper.prepare()来创建消息队列，会报"java.lang.RuntimeException: Can‘t create handler inside thread that has not called Looper.prepare()"的错误。

通过下图可以清晰显示出UI Thread, Worker Thread, Handler, Massage Queue, Looper之间的关系：

如上图：   UI Thread, Worker Thread, Handler, Massage Queue, Looper之间的关系

上图中的几个基本概念：

1.Message

消息对象，顾名思义就是记录消息信息的类。这个类有几个比较重要的字段：

a.arg1和arg2：我们可以使用两个字段用来存放我们需要传递的整型值，在Service中，我们可以用来存放Service的ID。

b.obj：该字段是Object类型，我们可以让该字段传递某个多项到消息的接受者中。

c.what：这个字段可以说是消息的标志，在消息处理中，我们可以根据这个字段的不同的值进行不同的处理，类似于我们在处理Button事件时，通过switch(v.getId())判断是点击了哪个按钮。

在使用Message时，我们可以通过new Message()创建一个Message实例，但是Android更推荐我们通过Message.obtain()或者Handler.obtainMessage()获取Message对象。这并不一定是直接创建一个新的实例，而是先从消息池中看有没有可用的Message实例，存在则直接取出并返回这个实例。反之如果消息池中没有可用的Message实例，则根据给定的参数new一个新Message对象。通过分析源码可得知，Android系统默认情况下在消息池中实例化10个Message对象。

2.MessageQueue

消息队列，用来存放Message对象的数据结构，按照“先进先出”的原则存放消息。存放并非实际意义的保存，而是将Message对象以链表的方式串联起来的。MessageQueue对象不需要我们自己创建，而是有Looper对象对其进行管理，一个线程最多只可以拥有一个MessageQueue。我们可以通过Looper.myQueue()获取当前线程中的MessageQueue。

3.Looper

MessageQueue的管理者，在一个线程中，如果存在Looper对象，则必定存在MessageQueue对象，并且只存在一个Looper对象和一个MessageQueue对象。倘若我们的线程中存在Looper对象，则我们可以通过Looper.myLooper()获取，此外我们还可以通过Looper.getMainLooper()获取当前应用系统中主线程的Looper对象。在这个地方有一点需要注意，假如Looper对象位于应用程序主线程中，则Looper.myLooper()和Looper.getMainLooper()获取的是同一个对象。

4.Handler

消息的处理者。通过Handler对象我们可以封装Message对象，然后通过sendMessage(msg)把Message对象添加到MessageQueue中；当MessageQueue循环到该Message时，就会调用该Message对象对应的handler对象的handleMessage()方法对其进行处理。由于是在handleMessage()方法中处理消息，因此我们应该编写一个类继承自Handler，然后在handleMessage()处理我们需要的操作。

另外，我们知道，Android UI操作并不是线程安全的，所以无法在子线程中更新UI。但Andriod提供了几种方法，可以在子线程中通知UI线程更新界面：

  • Activity.runOnUiThread( Runnable )
  • View.post( Runnable )
  • View.postDelayed( Runnable, long )
  • Handler

比较常用的是通过Handler，用Handler来接收子线程发送的数据，并用此数据配合主线程更新UI。那么，只要在主线程中创建Handler对象，在子线程中调用Handler的sendMessage方法，就会把消息放入主线程的消息队列，并且将会在Handler主线程中调用该handler的handleMessage方法来处理消息。

  1. package com.superonion;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.os.Message;
  5. import android.util.Log;
  6. import android.os.Handler;
  7. public class MyHandler extends Activity {
  8. static final String TAG = "Handler";
  9. Handler h = new Handler(){
  10. public void handleMessage (Message msg)
  11. {
  12. switch(msg.what)
  13. {
  14. case HANDLER_TEST:
  15. Log.d(TAG, "The handler thread id = " + Thread.currentThread().getId() + "\n");
  16. break;
  17. }
  18. }
  19. };
  20. static final int HANDLER_TEST = 1;
  21. /** Called when the activity is first created. */
  22. @Override
  23. public void onCreate(Bundle savedInstanceState) {
  24. super.onCreate(savedInstanceState);
  25. Log.d(TAG, "The main thread id = " + Thread.currentThread().getId() + "\n");
  26. new myThread().start();
  27. setContentView(R.layout.main);
  28. }
  29. class myThread extends Thread
  30. {
  31. public void run()
  32. {
  33. Message msg = new Message();
  34. msg.what = HANDLER_TEST;
  35. h.sendMessage(msg);
  36. Log.d(TAG, "The worker thread id = " + Thread.currentThread().getId() + "\n");
  37. }
  38. }
  39. }


  1. package com.superonion;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.os.Message;
  5. import android.util.Log;
  6. import android.os.Handler;
  7. public class MyHandler extends Activity {
  8. static final String TAG = "Handler";
  9. Handler h = new Handler(){
  10. public void handleMessage (Message msg)
  11. {
  12. switch(msg.what)
  13. {
  14. case HANDLER_TEST:
  15. Log.d(TAG, "The handler thread id = " + Thread.currentThread().getId() + "\n");
  16. break;
  17. }
  18. }
  19. };
  20. static final int HANDLER_TEST = 1;
  21. /** Called when the activity is first created. */
  22. @Override
  23. public void onCreate(Bundle savedInstanceState) {
  24. super.onCreate(savedInstanceState);
  25. Log.d(TAG, "The main thread id = " + Thread.currentThread().getId() + "\n");
  26. new myThread().start();
  27. setContentView(R.layout.main);
  28. }
  29. class myThread extends Thread
  30. {
  31. public void run()
  32. {
  33. Message msg = new Message();
  34. msg.what = HANDLER_TEST;
  35. h.sendMessage(msg);
  36. Log.d(TAG, "The worker thread id = " + Thread.currentThread().getId() + "\n");
  37. }
  38. }
  39. }

以上代码中，Handler在主线程中创建后，子线程通过sendMessage()方法就可以将消息发送到主线程中，并在handleMessage()方法中处理。

时间： 2024-10-29 13:29:08

关于android的UI更新机制与误区的相关文章

MFC的UI更新机制和加速键的创建

近期在看<MFC Windows程序设计>这本书,正好看到更新菜单中的菜单项和加入菜单项的加速键这方面的内容,下面总一下总结. MFC提供的更新菜单项的机制例如以下: 通过消息映射表中的ON_UPDATE_COMMAND_UI宏.能够给单个的菜单项分配选中的成员函数作为更新处理函数,当用户点中一个下拉菜单时,MFC捕获随之发生的WM_INITMENUPOPUP消息,并调用菜单中的全部菜单项的更新处理函数. 每一个更新处理函数获得一个指向CCmdUI对象的指针,并利用该对象的成员处理函数更新菜单

Android开发之UI更新交互机制与实例解析

android开发过程中,经常需要更新UI的状态和文案等.这是就需要对UI进行 更新.在android中更新UI一般有三种方法,handler机制.RunOnUiThread方法以及AsyncTask异步类方法等 本文下面就这三种方法进行了演示和代码实现. a.Handler机制通过使用消息机制来实现 b.RunOnUiThread方法是通过运行UI线程来达到更新UI的目的 c.AsyncTask是异步类,通过异步更新来更新UI 效果图如下:           (1)Java功能实现代码如下:

Android中使用Handler机制更新UI的三种解决方案

最近想把学习Android过程中的Handler使用经验写下来,供自己以后查看,也与大家一起分享. 使用Handler其实不得不与Android中的线程或者说Java中的多线程扯上关系.本篇文章只会用到最基本的线程使用,不会涉及太难的,关于Android的线程我们以后再讨论.在Android中每新建一个Activity,该Activity(理解为界面)就是一个线程,是一个主线程,也称之为UI线程.主线程可以更新界面元素,不会出现问题.每当新建一个线程new Thread,该线程就是一个子线程,A

Android子线程更新UI主线程方法之Handler

背景: 我们开发应用程序的时候,处于线程安全的原因子线程通常是不能直接更新主线程(UI线程)中的UI元素的,那么在Android开发中有几种方法解决这个问题,其中方法之一就是利用Handler处理的. 下面说下有关Handler相关的知识. 多线程一些基础知识回顾:在介绍Handler类相关知识之前,我们先看看在Java中是如何创建多线程的方法有两种:通过继承Thread类,重写Run方法来实现通过继承接口Runnable实现多线程 具体两者的区别与实现,看看这篇文章中的介绍:http://de

android开发之在activity中控制另一个activity的UI更新

转自:http://blog.csdn.net/jason0539/article/details/18075293 第一种方法: 遇到一个问题,需要在一个activity中控制另一个acitivity做一些更新,没想到传递handler的方法,通过以下方式解决. 1.在MyAPP中定义属性handler 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 package jason.com;     import jas

android中子线程更新UI的方式浅析

一.为何写作此文 ??你是不是经常看到很多书籍中说:不能在子线程中操作ui,不然会报错.你是不是也遇到了如下的疑惑(见下面的代码): @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); tv = (TextView) findViewById(R.id.tv); Threa

Android 非UI线程中更新UI

Android 非UI线程中更新UI runOnUiThread(new Runnable() { public void run() { onDown(null); } });

Android关于线程更新UI的方法

Android关于线程更新UI的方法 在一个Android 程序开始运行的时候,会单独启动一个Process.默认的情况下,所有这个程序中的Activity或者Service(Service和 Activity只是Android提供的Components中的两种,除此之外还有Content Provider和Broadcast Receiver)都会跑在这个Process.   一个Android 程序默认情况下也只有一个Process,但一个Process下却可以有许多个Thread.   在

Android 子线程更新UI 异常

众所周知,Android是不可以在子线程中直接更新UI的,需要借助Handler或者View.post(Runnable runnable)或者runOnUIThread(Runnable runnable)将更新的代码切入到主线程中去实现UI更新. 我们来试一下,在Activity的 onCreate中直接在新线程中去更新一个TextView的文本,结果发现,WHAT?竟然没有抛出异常,更新也成功了? 这是因为在onCreate中尚未完成View的绘制,此时TextView中有个变量mLayo