`
xifangyuhui
  • 浏览: 188661 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

活用Android的Message Queue(2)

AndroidFPthreadUI.net 
阅读更多

1.       复习Message Queue的角色

在上一篇里，介绍了Android的Thread、Looper、Message Queue和Handler四者间之关系。

先复习如下：

l   UI thread 通常就是main thread，而Android启动程序时(即创建Process时)会替它建立一个Message Queue。

l   当然需要一个Looper对象，来管理该Message Queue。

l   我们可以创建Handler对象来push新消息到Message Queue里；或者接收Looper(从Message Queue取出)所送来的消息。

l   线程A的Handler对象引用可以传递给别的线程，让别的线程B或C等能发送消息来给线程A(存于A的Message Queue里)。

l   线程A的Message Queue里的消息，只有线程A所属的对象可以处理之。

 

 了解了四者间之关系后，在本篇里，就能来思考如何让主线程与子线程之间互相沟通了。包括，子线程push消息到主线程的Message Queue里，并触发主线程去执行某项工作(即执行某个函数)。

 

2.  由别的线程发送消息到主线程的Message Queue(续)

    在上一篇文章里，使用如下程序片段：

// class ac01 extends Activity {

          // ………

              public void onClick(View v) {

                     switch(v.getId()){

                     case 101:

                           t = new myThread();

                           t.start();

                          break;

                     case 102:

                  finish();

                                break;

                     }

           }

//------------------------------------------------------             

class EHandler extends Handler {

                   public EHandler(Looper looper) {

                       super(looper);

                   }

                   @Override

                   public void handleMessage(Message msg) {

                      tv.setText((String)msg.obj);

               }

           }

//------------------------------------------------------             

class myThread extends Thread{

            private EHandler mHandler;

            public void run() {

                Looper myLooper, mainLooper;

                myLooper = Looper.myLooper();

                mainLooper = Looper.getMainLooper();

                String obj;

                if(myLooper == null){

                       mHandler = new EHandler(mainLooper);

                       obj = "current thread has no looper!";

                }

                else {

                     mHandler = new EHandler(myLooper);

                     obj = "This is from current thread.";

                }

                mHandler.removeMessages(0);

                Message m = mHandler.obtainMessage(1, 1, 1, obj);

                mHandler.sendMessage(m);

             }

  }

}

  

这个mHandler定义于myThread类别里，而且由子线程执行指令：      mHandler = new EHandler(mainLooper);

来创建EHandler对象；但是这个mHandler确是属于main线程的(用来存取主线程的MessageQueue)，所以指令：

mHandler.sendMessage(m);是将m丢到主线程的MessageQueue里。

此外，我们也可以将mHandler定义于ac01类别里。如下程序范例：

 

//----- Looper_03范例 -----

public class ac01 extends Activity implements OnClickListener {

    private final int WC = LinearLayout.LayoutParams.WRAP_CONTENT;

    private final int FP = LinearLayout.LayoutParams.FILL_PARENT;

    public TextView tv;

    private myThread t;

    private Button btn, btn2;

    EventHandler h;

    Context ctx;

    public void onCreate(Bundle icicle) {

            super.onCreate(icicle);

            ctx = this;

                LinearLayout layout = new LinearLayout(this);

                layout.setOrientation(LinearLayout.VERTICAL);

                              

                btn = new Button(this);

                btn.setId(101);

                btn.setBackgroundResource(R.drawable.heart);

                btn.setText("test looper");

                btn.setOnClickListener(this);

                LinearLayout.LayoutParams param =

                    new LinearLayout.LayoutParams(100,50);

                param.topMargin = 10;

                layout.addView(btn, param);

               

                btn2 = new Button(this);

                btn2.setId(102);

                btn2.setBackgroundResource(R.drawable.ok_blue);

                btn2.setText("exit");

                btn2.setOnClickListener(this);

                layout.addView(btn2, param);

               

                tv = new TextView(this);

                tv.setTextColor(Color.WHITE);

                tv.setText("");

                LinearLayout.LayoutParams param2 =

                   new LinearLayout.LayoutParams(FP, WC);

                param2.topMargin = 10;

                layout.addView(tv, param2);

                setContentView(layout);     

               }

          public void onClick(View v) {

        switch(v.getId()){

        case 101:

             h = new EventHandler(Looper.myLooper());

             t = new myThread();

             t.start();

             break;

        case 102:

       finish();

            break;

        }

    }

//------------------------------------------------     

public class EventHandler extends Handler {

            public EventHandler(Looper looper) {

                 super(looper);

             }

             @Override

             public void handleMessage(Message msg) {

                      ((Activity)ctx).setTitle((String)msg.obj);

             }

          }

//------------------------------------------------------      

class myThread extends Thread{

     public void run() {

            String obj = "from myThread";

            Message m = h.obtainMessage(1, 1, 1, obj);

            h.sendMessage(m);

      }

  }

}

//------------------------------------------------------

 

指令：h = new EventHandler(Looper.myLooper());

此h是属于main线程的(用来存取主线程的MessageQueue)。在myThread类别里的指令：h.sendMessage(m);

虽然是由子线程执行该指令，还是将m丢到主线程的MessageQueue里。于是，子线程所执行的run()函数，就顺利将m丢给主线程(的Message Queue)，并触发了主线程去执行handleMessage()函数了。显示出画面如下：

 

 

 图1  

 

上述的指令：

 

          myLooper = Looper.myLooper();

          mainLooper = Looper.getMainLooper();

                ………

          mHandler = new EHandler(mainLooper);

                  ………

          mHandler = new EHandler(myLooper);

                    ………

 

都明显地指明mHandler是负责存取哪一个线程的Message Queue。不过，有时候并不需要特别指明。例如上述的onClick()函数和EventHandler类别，可改写为：

 

//----- Looper_03aa 范例 -----

// class ac01 extends Activity {

          // ………

       public void onClick(View v) {

        switch(v.getId()){

        case 101:

             h = new EventHandler();

             t = new myThread();

             t.start();

             break;

        case 102:

              finish();

            break;

        }

    }

//------------------------------------------------     

public class EventHandler extends Handler {

             @Override

             public void handleMessage(Message msg) {

                      ((Activity)ctx).setTitle((String)msg.obj);

             }

          }

//------------------------------------------------------      

class myThread extends Thread{

     public void run() {

            String obj = "from myThread";

            Message m = h.obtainMessage(1, 1, 1, obj);

            h.sendMessage(m);

      }

  }

}

 

指令：h = new EventHandler();  就等于：h = new EventHandler(Looper.myLooper());

它建立了当前线程(Current Thread)的EventHandler对象。于此，是由main线程执行此指令的，所以此EventHandler对象是用来存取main线程的Message Queue。

上述程序将handleMessage()定义于EventHandler类别内，也可以直接定义于ac01类别之内。于是上述程序，也相当于：

 

//----- Looper_03bb 范例 -----

// class ac01 extends Activity {

          // ………

          public void onClick(View v) {

        switch(v.getId()){

        case 101:

             h = new Handler(){

                 public void handleMessage(Message msg) {

                      ((Activity)ctx).setTitle((String)msg.obj);

             }};

              t = new myThread();

             t.start();

             break;

        case 102:

        finish();

            break;

        }

    }

//------------------------------------------------------      

class myThread extends Thread{

     public void run() {

            String obj = "from myThread...";

            Message m = h.obtainMessage(1, 1, 1, obj);

            h.sendMessage(m);

      }

  }

}

 

其执行结果是一样的。

 

转自：http://www.android1.net/Topic.aspx?BoardID=11&TopicID=631

分享到：
| 活用Android的Message Queue(1)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    活用Android的Message Queue

    在Android开发中，Message Queue是一种重要的机制，用于在不同线程间进行异步通信和任务调度。理解并熟练运用Message Queue、Looper和Handler是构建高效、响应性良好的Android应用的关键。 1. **Message Queue...

    android MessageQueue

    通过阅读《android MessageQueue1.doc》、《android MessageQueue2.doc》和《android MessageQueue3.doc》，你可以更深入地了解MessageQueue的实现细节、使用技巧以及常见问题的解决方案，这对于提升Android应用的...

    Android的消息处理机制--Message，MessageQueue

    本篇文章将详细探讨Android的消息处理机制，特别是Message和MessageQueue这两个核心概念。 #### 二、Android消息处理机制概述 当Android应用启动后，会创建一个主进程，在这个进程中包含了UI主线程。UI主线程负责...

    活用Android的Message_Queue(2)

    在Android开发中，Message Queue（消息队列）是多线程通信的核心机制，尤其是在主线程（UI线程）与其他工作线程之间的交互中起到至关重要的作用。本文将深入探讨Message Queue的工作原理及其在Android中的应用。 1....

    Message,MessageQueue,Looper,Handler详解

    通常情况下，我们会使用一个Looper对象对线程的MessageQueue进行管理。在Android应用的主线程创建时，会默认创建一个Looper对象，而这个Looper对象的创建会自动创建一个MessageQueue。对于其他非主线程来说，默认...

    Handler Looper MessageQueue 源码解析

    2. 使用Handler的`sendMessage()`或`post()`方法发送一个Message到MessageQueue。 3. Looper在主线程中持续检查MessageQueue，发现新消息后，取出并交给对应Handler的`handleMessage()`方法处理。 要手写一套自己的...

    android_os_MessageQueue.rar_android

    在Android操作系统中，MessageQueue是实现线程间通信和异步处理的核心组件。它与Handler、Looper紧密协作，构成了Android消息传递机制的基础。本压缩包文件"android_os_MessageQueue.rar_android"显然关注的是这一...

    Android Message Queue

    - Looper会创建一个MessageQueue数据结构，用于存放消息。每个线程可以有一个Looper对象和一个MessageQueue。 3. **使用示例** ```java // 创建一个新的Handler实例，关联当前线程的Looper mHandler = new ...

    管理MessageQueue的Looper

    在Android系统中，MessageQueue和Looper是两个非常关键的组件，它们构成了消息处理机制的核心，尤其是在UI线程中。理解并有效地使用它们对于编写高效、响应迅速的Android应用至关重要。 `Looper`是Android中的一个...

    Handler+Looper+MessageQueue

    【Android 线程间通信：Handler、Looper 和 MessageQueue 深度解析】 在 Android 应用开发中，为了保证界面的流畅性，我们通常需要将耗时操作放在非 UI 线程中执行，然后通过某种机制将结果传递回 UI 线程进行界面...

    Talking about Android Message Queue

    在Android系统中，消息队列（Message Queue）是线程间通信的重要机制，尤其是在处理UI更新和异步任务时。然而，与Windows操作系统不同，Android并没有实现全局的消息队列来支持跨进程通信，而是主要依赖于Intent来...

    Thread,Looper,Handler,Message,MessageQueue,MessagePool之间的关系

    在Android系统中，线程（Thread）、Looper、Handler、Message以及MessageQueue和MessagePool是实现异步消息处理机制的关键组件，它们共同构建了一个高效的事件驱动模型。这些组件的关系紧密，协同工作，使得Android...

    Android7.0 MessageQueue详解

    一直以来，觉得MessageQueue应该是Java层的抽象，然而事实上MessageQueue的主要部分在Native层中。 自己对MessageQueue在Native层的工作不太熟悉，借此机会分析一下。 一、MessageQueue的创建 当需要使用Looper时...

    Android¦-Message Queue

    - **MessageQueue的创建**：Looper会创建一个MessageQueue，用于存储各个对象发送的消息，包括用户界面事件和系统事件。 - **定义Handler子类**：开发者可以定义Handler的子类来接收Looper分发的消息。Handler子类...

    Android 之 Looper、MessageQueue、Handler 与消息循环

    ### Android之Looper、MessageQueue、Handler与消息循环详解 #### 一、概述 在Android开发过程中，消息处理机制是至关重要的部分，它涉及到应用程序如何管理、传递和响应各种事件。本篇文章将深入探讨Android中...

    Android 异步处理 Handler+Looper+MessageQueue深入详解

    Handler、Looper和MessageQueue是Android异步处理机制中的核心组件，它们共同构建了一个消息传递系统，使得在不同线程间进行数据交换变得可能。下面我们将深入探讨这三个组件的工作原理及其在实际开发中的应用。 ...

    Android单线程模型中Message、Handler、Message Queue、Looper之间的关系---附实例源码

    Handler获取当前线程中的looper对象，looper用来从存放Message的MessageQueue中取出Message，再有Handler进行Message的分发和处理. 简单定义： 1、Message Queue(消息队列)： 用来存放通过Handler发布的消息，通常...

    Message,MessageQueue,Looper,Handler详解[归类].pdf

    Handler有两种主要的使用方式：一是通过`sendMessage()`系列方法将Message放入MessageQueue，二是通过`handleMessage()`方法处理从Looper传来的消息。Handler还提供了`post()`方法，用于将Runnable对象放入Message...

    详细分析android的MessageQueue.IdleHandler

    我们知道android是基于Looper消息循环的系统，我们通过Handler向Looper包含的MessageQueue投递Message, 不过我们常见的用法是这样吧？ 一般我们比较少接触MessageQueue, 其实它内部的IdleHandler接口有很多有趣的...

Magicbox
Global site tag (gtag.js) - Google Analytics