Android消息处理－概念普及篇

一、Android消息处理－概念普及篇

1.概述

         本文将介绍Android消息处理涉及的相关概念，并较深入地阐述了这些事物之间的关系。

 

2.要点

         A。基本概念普及

         B。深入解析消息处理

 

3. 概念普及

         3.1 Android应用程序与进程

         当一个程序第一次启动的时候，Android会启动一个LINUX进程和一个主线程。默认的情况下，所有该程序的组件都将在该进程和线程中运行。

 

3.2 Android线程

 

3.2.1主线程/UI线程：

当应用程序的进程被创建后，它的主线程专门用来运行消息队列，此消息队列关注于管理最上层的应用程序对象（活动、广播接收者，等）和它所创建的任何窗口（我的理解：主线程还负责处理与UI相关的事件，如用户的按键事件，用户接触屏幕的事件以及屏幕绘图事件，并把相关的事件分发到对应的组件进行处理）。所以主线程通常又被叫做UI线程。在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。

 

3.2.2工作线程：

默认创建的线程。它是没有消息循环和消息队列的。当然也可以为其添加此，具体参见Goolge API DOC.

 

3.3 子线程更新UI

     Android的UI是单线程(Single-threaded)的。为了避免拖住GUI，一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象，Android就会发出错误讯息 CalledFromWrongThreadException。以后遇到这样的异常抛出时就要知道怎么回事了！[因此,这里常借助Handler, 与主线程(UI线程)的消息循环相关联, 以传递UI更新消息致其更新]

 

3.4消息队列（Message Queue）

         在单线程模型下，为了解决类似的问题，Android设计了一个Message Queue(消息队列)， 线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。

 

3.4.1 Message

    Message消息，理解为线程间交流的信息，处理数据后台线程需要更新UI，则发送Message内含一些数据给UI线程。

 

3.4.2Handler

    Handler处理者，是Message的主要处理者，负责Message的发送，Message内容的执行处理。后台线程就是通过传进来的Handler对象引用来sendMessage(Message)。而使用Handler，需要implement该类的 handleMessage(Message)方法，它是处理这些Message的操作内容，例如Update UI。通常需要子类化Handler来实现handleMessage方法。

 

3.4.3Message Queue

    Message Queue消息队列，用来存放通过Handler发布的消息，按照先进先出执行。

    每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息：sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同：通过sendMessage发送的是一个message对象,会被Handler的handleMessage()函数处理；而通过post方法发送的是一个runnable对象，则会自己执行。

 

3.4.4Looper

Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue，而Android会自动替主线程(UI线程)建立Message Queue，但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL，但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL。

 

[以上3.1-3.4转自：http://android.blog.51cto.com/268543/343823，并略作整理]

 

4. Looper、 Handler 深入理解消息处理

 

    熟悉Windows编程的朋友可能知道Windows程序是消息驱动的，并且有全局的消息循环系统。而Android应用程序也是消息驱动的，按道理来说也应该提供消息循环机制。实际上谷歌参考了Windows的消息循环机制，也在Android系统中实现了消息循环机制。Android通过Looper、Handler来实现消息循环机制，Android消息循环是针对线程的（每个线程都可以有自己的消息队列和消息循环）。本文深入介绍一下Android消息处理系统原理。

    Android系统中Looper负责管理线程的消息队列和消息循环（具体实现请参考Looper的源码）。可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。

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

  class LooperThread extends Thread {      
    public Handler mHandler;       
    public void run() {         
        Looper.prepare();   //创建本线程的Looper并创建一个MessageQueue        
        mHandler = new Handler() {           
            publicvoid handleMessage(Message msg) {
                       // process incoming messages here    
             }      
        };         
        Looper.loop();      //开始运行Looper,监听Message Queue
    }  
}

[他人释意：

这个Message机制的大概流程：

    1. 在Looper.loop()方法运行开始后，循环地按照接收顺序取出MessageQueue里面的非NULL的Message。

    2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue，该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message，则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。

    在dispatchMessage方法里，如何处理Message则由用户指定，三个判断，优先级从高到低：

    1) Message里面的Callback，一个实现了Runnable接口的对象，其中run函数做处理工作；

    2) Handler里面的mCallback指向的一个实现了Callback接口的对象，由其handleMessage进行处理；

    3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数，通过这个实现的handleMessage函数处理消息。

    由此可见，我们实现的handleMessage方法是优先级最低的！

    3. Handler处理完该Message (update UI) 后，Looper则设置该Message为NULL，以便回收！

]

 

这样你的线程就具有了消息处理机制了，在Handler中进行消息处理。

     Activity是一个UI线程，运行于主线程中，Android系统在启动的时候会为Activity创建一个消息队列和消息循环（Looper）（详细实现请参考ActivityThread.java文件）。

     Handler的作用是把消息加入特定的（Looper）消息队列中，并分发和处理该消息队列中的消息。构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper创建（详细实现请参考Looper的源码）。

Activity、Looper、Handler的关系如右图所示：

 

一个Activity中可以创建多个工作线程或者其他的组件，如果这些线程或者组件把他们的消息放入Activity的主线程消息队列，那么该消息就会在主线程中处理了。因为主线程一般负责界面的更新操作，并且Android系统中的widget不是线程安全的，所以这种方式可以很好的实现Android界面更新。在Android系统中这种方式有着广泛的运用。

     那么另外一个线程怎样把消息放入主线程的消息队列呢？答案是通过Handle对象，只要Handler对象以主线程的Looper创建，那么调用Handler的sendMessage等接口，将会把消息放入队列都将是放入主线程的消息队列。并且将会在Handler主线程中调用该handler的handleMessage接口来处理消息。

     这里面涉及到线程同步问题，请先参考如下例子来理解Handler对象的线程模型：

1、首先创建MyHandler工程。

2、在MyHandler.java中加入如下的代码：

packagecom.simon; 
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.os.Message;
importandroid.util.Log;
importandroid.os.Handler;
 
 public class MyHandler extends Activity {
    staticfinal String TAG = "Handler"; 
    Handler h = new Handler(){  
        publicvoid handleMessage (Message msg) { 
                 switch(msg.what){   
                caseHANDLER_TEST:     
                    Log.d(TAG,"The handler thread id = " + Thread.currentThread().getId() +"\n");        break; 
             }    
        }  
     }; 
    staticfinal int HANDLER_TEST = 1;     /**Called when the activity is first created. */    
    @Override    
    public void onCreate(BundlesavedInstanceState) {    
        super.onCreate(savedInstanceState);   
         Log.d(TAG,"The main thread id = " + Thread.currentThread().getId() +"\n");  
         newmyThread().start();     
        setContentView(R.layout.main);   
    }     
 
    class myThread extends Thread     {  
        publicvoid run()      { 
             Messagemsg = new Message(); 
             msg.what= HANDLER_TEST;    
            h.sendMessage(msg);  
         Log.d(TAG,"The worker thread id = " + Thread.currentThread().getId() +"\n");  
        } 
   }
}

在这个例子中我们主要是打印，这种处理机制各个模块的所处的线程情况。如下是我的机器运行结果：

09-10 23:40:51.478:DEBUG/Handler(302): The main thread id = 1

09-10 23:40:51.569:DEBUG/Handler(302): The worker thread id = 8

09-10 23:40:52.128:DEBUG/Handler(302): The handler thread id = 1

 

我们可以看出消息处理是在主线程中处理的，在消息处理函数中可以安全的调用主线程中的任何资源，包括刷新界面。工作线程和主线程运行在不同的线程中，所以必须要注意这两个线程间的竞争关系。

     上例中，你可能注意到在工作线程中访问了主线程handler对象，并在调用handler的对象向消息队列加入了一个消息。这个过程中会不会出现消息队列数据不一致问题呢？答案是handler对象不会出问题，因为handler对象管理的Looper对象是线程安全的，不管是加入消息到消息队列和从队列读出消息都是有同步对象保护的，具体请参考Looper.java文件。上例中没有修改handler对象，所以handler对象不可能会出现数据不一致的问题。

     通过上面的分析，我们可以得出如下结论：

1、如果通过工作线程刷新界面，推荐使用handler对象来实现。

2、注意工作线程和主线程之间的竞争关系。推荐handler对象在主线程中构造完成（并且启动工作线程之后不要再修改之，否则会出现数据不一致），然后在工作线程中可以放心的调用发送消息SendMessage等接口。

3、除了2所述的hanlder对象之外的任何主线程的成员变量如果在工作线程中调用，仔细考虑线程同步问题。如果有必要需要加入同步对象保护该变量（加锁，因为多个线程同时读写同一数据）。

4、handler对象的handleMessage接口将会在主线程中调用。在这个函数可以放心的调用主线程中任何变量和函数，进而完成更新UI的任务。

5、Android很多API也利用Handler这种线程特性，作为一种回调函数的变种，来通知调用者。这样Android框架就可以在其线程中将消息发送到调用者的线程消息队列之中，不用担心线程同步的问题。

 

     深入理解Android消息处理机制对于应用程序开发非常重要，也可以让你对线程同步有更加深刻的认识。以上是最近Simon学习Android消息处理机制的一点儿总结，如有错误之处请不吝指教。

         [以上转自：http://li-bonan.blog.163.com/blog/static/13556477020112245111485/]

 

 

5.总结

         本文先由概念逐步引出主题，降低了理解难度。通过转载并整理他人博客，串联了理解所需的各知识点。