Android编程之消息机制实例分析

本文实例讲述了android编程之消息机制。分享给大家供大家参考，具体如下：

一、角色描述

1.looper: 一个线程可以产生一个looper对象，由它来管理此线程里的message queue(消息队列)。

2.handler: 你可以构造handler对象来与looper沟通，以便push新消息到message queue里；或者接收looper(从message queue取出)所送来的消息。

3. message queue(消息队列):用来存放线程放入的消息。

4．线程：ui thread 通常就是main thread，而android启动程序时会替它建立一个message queue。

每一个线程里可含有一个looper对象以及一个messagequeue数据结构。在你的应用程序里，可以定义handler的子类别来接收looper所送出的消息。
 
在你的android程序里，新诞生一个线程，或执行 (thread)时，并不会自动建立其message loop。

android里并没有global的message queue数据结构，例如，不同apk里的对象不能透过massage queue来交换讯息(message)。

例如：线程a的handler对象可以传递消息给别的线程，让别的线程b或c等能送消息来给线程a(存于a的message queue里)。

线程a的message queue里的讯息，只有线程a所属的对象可以处理。

使用looper.mylooper可以取得当前线程的looper对象。

使用mhandler = new eevnthandler(looper.mylooper()); 可用来构造当前线程的handler对象；其中，eevnthandler是自已实现的handler的子类别。

使用mhandler = new eevnthandler(looper.getmainlooper()); 可诞生用来处理main线程的handler对象；其中，eevnthandler是自已实现的handler的子类别。
 
这样描述可能太抽像，下面举几个实际的例子来说明：

二、举例

1. 同线程内不同组件间的消息传递

looper类用来管理特定线程内对象之间的消息交换(message exchange)。你的应用程序可以产生许多个线程。而一个线程可以有许多个组件，这些组件之间常常需要互相交换讯息。如果有这种需要，您可以替线程构造一个looper对象，来担任讯息交换的管理工作。looper对象会建立一个messagequeue数据结构来存放各对象传来的消息(包括ui事件或system事件等)。

每一个线程里可含有一个looper对象以及一个messagequeue数据结构。在你的应用程序里，可以定义handler的子类别来接收looper所送出的消息。

同线程不同组件之间的消息传递：

public class activity1 extends activity implements onclicklistener{
  button button = null;
  textview text = null;
  @override
  protected void oncreate(bundle savedinstancestate) {
    super.oncreate(savedinstancestate);
    setcontentview(r.layout.activity1);
    button = (button)findviewbyid(r.id.btn);
    button.setonclicklistener(this);
    text = (textview)findviewbyid(r.id.content);
  }
  public void onclick(view v) {
    switch (v.getid()) {
    case r.id.btn:
      looper looper = looper.mylooper();//取得当前线程里的looper
      myhandler mhandler = new myhandler(looper);//构造一个handler使之可与looper通信
      //buton等组件可以由mhandler将消息传给looper后,再放入messagequeue中,同时mhandler也可以接受来自looper消息
      mhandler.removemessages(0);
      string msgstr = "主线程不同组件通信:消息来自button";
      message m = mhandler.obtainmessage(1, 1, 1, msgstr);//构造要传递的消息
      mhandler.sendmessage(m);//发送消息:系统会自动调用handlemessage方法来处理消息
      break;
    }
  }
  private class myhandler extends handler{
    public myhandler(looper looper){
      super(looper);
    }
    @override
    public void handlemessage(message msg) {//处理消息
      text.settext(msg.obj.tostring());
    }
  }
}

说明：

此程序启动时，当前线程(即主线程, main thread)已诞生了一个looper对象，并且有了一个messagequeue数据结构。

looper = looper.mylooper ();

调用looper类别的静态mylooper()函数，以取得目前线程里的looper对象.

mhandler = new myhandler (looper);

构造一个myhandler对象来与looper沟通。activity等对象可以藉由myhandler对象来将消息传给looper，然后放入messagequeue里；myhandler对象也扮演listener的角色，可接收looper对象所送来的消息。

message m = mhandler.obtainmessage(1, 1, 1, obj);

先构造一个message对象，并将数据存入对象里。

mhandler.sendmessage(m);

就透过mhandler对象而将消息m传给looper，然后放入messagequeue里。

此时，looper对象看到messagequeue里有消息m，就将它广播出去，mhandler对象接到此讯息时，会呼叫其handlemessage()函数来处理，于是输出"this my message!"于画面上，
角色综述（回顾）:

(1)ui thread 通常就是main thread，而android启动程序时会替它建立一个messagequeue。
(2)当然需要一个looper对象，来管理该messagequeue。
(3)我们可以构造handler对象来push新消息到message queue里；或者接收looper(从message queue取出)所送来的消息。
(4)线程a的handler对象可以传递给别的线程，让别的线程b或c等能送讯息来给线程a(存于a的message queue里)。
(5)线程a的message queue里的消息，只有线程a所属的对象可以处理。
 
子线程传递消息给主线程

public class activity2 extends activity implements onclicklistener{
  button button = null;
  textview text = null;
  myhandler mhandler = null;
  thread thread ;
  @override
  protected void oncreate(bundle savedinstancestate) {
    super.oncreate(savedinstancestate);
    setcontentview(r.layout.activity1);  
    button = (button)findviewbyid(r.id.btn);
    button.setonclicklistener(this);
    text = (textview)findviewbyid(r.id.content);
  }
  public void onclick(view v) {
    switch (v.getid()) {
    case r.id.btn:
      thread = new mythread();
      thread.start();
      break;
    }   
  }  
  private class myhandler extends handler{    
    public myhandler(looper looper){
      super(looper);
    }
    @override
    public void handlemessage(message msg) {//处理消息
      text.settext(msg.obj.tostring());
    }   
  }
  private class mythread extends thread{
    @override
    public void run() {
      looper curlooper = looper.mylooper();
      looper mainlooper = looper.getmainlooper();
      string msg ;
      if(curlooper==null){
       mhandler = new myhandler(mainlooper);
       msg = "curlooper is null";
      }else{
       mhandler = new myhandler(curlooper);
       msg = "this is curlooper";
      }
      mhandler.removemessages(0);
      message m = mhandler.obtainmessage(1, 1, 1, msg);
      mhandler.sendmessage(m);
    }
  }
}

说明：

android会自动替主线程建立message queue。在这个子线程里并没有建立message queue。所以，mylooper值为null，而mainlooper则指向主线程里的looper。于是，执行到：

mhandler = new myhandler (mainlooper);

此mhandler属于主线程。

mhandler.sendmessage(m);

就将m消息存入到主线程的message queue里。mainlooper看到message queue里有讯息，就会作出处理，于是由主线程执行到mhandler的handlemessage()来处理消息。

希望本文所述对大家android程序设计有所帮助。