`
fedora1979
  • 浏览: 9649 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

android中Message机制的灵活应用

AndroidthreadFPOSUI 
阅读更多

android中Message机制的灵活应用

关键字: 消息机制 handler looper 线程间通信 message messagequeue

引用
来自easyandroid论坛，原文：http://www.easyandroid.com/bbs/viewthread.php?tid=33

1.活用Android线程间通信的Message机制

1.1.Message
代码在frameworks\base\core\java\android\Os\Message.java中。

Message.obtain函数：有多个obtain函数，主要功能一样，只是参数不一样。作用是从Message Pool中取出一个Message，如果Message Pool中已经没有Message可取则新建一个Message返回，同时用对应的参数给得到的Message对象赋值。

Message Pool：大小为10个；通过Message.mPool->（Message并且Message.next）-> （Message并且Message.next）-> （Message并且Message.next）...构造一个Message Pool。Message Pool的第一个元素直接new出来，然后把Message.mPool（static类的static变量）指向它。其他的元素都是使用完的 Message通过Message的recycle函数清理后放到Message Pool（通过Message Pool最后一个Message的next指向需要回收的Message的方式实现）。下图为Message Pool的结构：


1.2.MessageQueue
MessageQueue里面有一个收到的Message的对列：

MessageQueue.mMessages(static变量)->( Message并且Message.next)-> ( Message并且Message.next)->...，下图为接收消息的消息队列：

上层代码通过Handler的sendMessage等函数放入一个message到MessageQueue里面时最终会调用MessageQueue的 enqueueMessage函数。enqueueMessage根据上面的接收的Message的队列的构造把接收到的Message放入队列中。

MessageQueue的removeMessages函数根据上面的接收的Message的队列的构造把接收到的Message从队列中删除，并且调用对应Message对象的recycle函数把不用的Message放入Message Pool中。

1.3.Looper
Looper对象的创建是通过prepare函数，而且每一个Looper对象会和一个线程关联

Java代码 复制代码
  1. public static final void prepare() {   
  2.     if (sThreadLocal.get() != null) {   
  3.         throw new RuntimeException("Only one Looper may be created per thread");   
  4.     }   
  5.     sThreadLocal.set(new Looper());   
  6. }  
public static final void prepare() {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper());
}


Looper对象创建时会创建一个MessageQueue，主线程默认会创建一个Looper从而有MessageQueue，其他线程默认是没有 MessageQueue的不能接收Message，如果需要接收Message则需要通过prepare函数创建一个MessageQueue。具体操作请见示例代码。

Java代码 复制代码
  1. private Looper() {   
  2.     mQueue = new MessageQueue();   
  3.     mRun = true;   
  4.     mThread = Thread.currentThread();   
  5. }  
private Looper() {
    mQueue = new MessageQueue();
    mRun = true;
    mThread = Thread.currentThread();
}


prepareMainLooper函数只给主线程调用（系统处理，程序员不用处理），它会调用prepare建立Looper对象和MessageQueue。

Java代码 复制代码
  1. public static final void prepareMainLooper() {   
  2.     prepare();   
  3.     setMainLooper(myLooper());   
  4.     if (Process.supportsProcesses()) {   
  5.         myLooper().mQueue.mQuitAllowed = false;   
  6.     }   
  7. }  
public static final void prepareMainLooper() {
    prepare();
    setMainLooper(myLooper());
    if (Process.supportsProcesses()) {
        myLooper().mQueue.mQuitAllowed = false;
    }
}


Loop函数从MessageQueue中从前往后取出Message，然后通过Handler的dispatchMessage函数进行消息的处理（可见消息的处理是Handler负责的），消息处理完了以后通过Message对象的recycle函数放到Message Pool中，以便下次使用，通过Pool的处理提供了一定的内存管理从而加速消息对象的获取。至于需要定时处理的消息如何做到定时处理，请见 MessageQueue的next函数，它在取Message来进行处理时通过判断MessageQueue里面的Message是否符合时间要求来决定是否需要把Message取出来做处理，通过这种方式做到消息的定时处理。

Java代码 复制代码
  1. public static final void loop() {   
  2.     Looper me = myLooper();   
  3.     MessageQueue queue = me.mQueue;   
  4.     while (true) {   
  5.         Message msg = queue.next(); // might block   
  6.         //if (!me.mRun) {   
  7.         //    break;   
  8.         //}   
  9.         if (msg != null) {   
  10.             if (msg.target == null) {   
  11.                 // No target is a magic identifier for the quit message   
  12.                 return;   
  13.             }   
  14.   
  15.             if (me.mLogging!= null)    
  16.                 me.mLogging.println(">>>>> Dispatching to " + msg.target + " "+ msg.callback + ": " + msg.what);   
  17.             msg.target.dispatchMessage(msg);   
  18.             if (me.mLogging!= null)    
  19.                 me.mLogging.println("<<<<< Finished to" + msg.target + " "+ msg.callback);   
  20.             msg.recycle();   
  21.         }   
  22.     }   
  23. }  
public static final void loop() {
    Looper me = myLooper();
    MessageQueue queue = me.mQueue;
    while (true) {
        Message msg = queue.next(); // might block
        //if (!me.mRun) {
        //    break;
        //}
        if (msg != null) {
            if (msg.target == null) {
                // No target is a magic identifier for the quit message
                return;
            }

            if (me.mLogging!= null) 
                me.mLogging.println(">>>>> Dispatching to " + msg.target + " "+ msg.callback + ": " + msg.what);
            msg.target.dispatchMessage(msg);
            if (me.mLogging!= null) 
                me.mLogging.println("<<<<< Finished to" + msg.target + " "+ msg.callback);
            msg.recycle();
        }
    }
}


1.4.Handler

Handler的构造函数表示Handler会有成员变量指向Looper和MessageQueue，后面我们会看到没什么需要这些引用；至于callback是实现了Callback接口的对象，后面会看到这个对象的作用。

Java代码 复制代码
  1. public Handler(Looper looper, Callback callback) {   
  2.     mLooper = looper;   
  3.     mQueue = looper.mQueue;   
  4.     mCallback = callback;   
  5. }   
  6.   
  7. public interface Callback {   
  8.     public boolean handleMessage(Message msg);   
  9. }  
public Handler(Looper looper, Callback callback) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
}

public interface Callback {
    public boolean handleMessage(Message msg);
}


获取消息：直接通过Message的obtain方法获取一个Message对象。

Java代码 复制代码
  1. public final Message obtainMessage(int what, int arg1, int arg2, Object obj){   
  2.     return Message.obtain(this, what, arg1, arg2, obj);   
  3. }  
public final Message obtainMessage(int what, int arg1, int arg2, Object obj){
    return Message.obtain(this, what, arg1, arg2, obj);
}


发送消息：通过MessageQueue的enqueueMessage把Message对象放到MessageQueue的接收消息队列中

Java代码 复制代码
  1. public boolean sendMessageAtTime(Message msg, long uptimeMillis){   
  2.     boolean sent = false;   
  3.     MessageQueue queue = mQueue;   
  4.     if (queue != null) {   
  5.         msg.target = this;   
  6.     sent = queue.enqueueMessage(msg, uptimeMillis);   
  7.     } else {   
  8.         RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");   
  9.         Log.w("Looper", e.getMessage(), e);   
  10.     }   
  11.     return sent;   
  12. }  
public boolean sendMessageAtTime(Message msg, long uptimeMillis){
    boolean sent = false;
    MessageQueue queue = mQueue;
    if (queue != null) {
        msg.target = this;
    sent = queue.enqueueMessage(msg, uptimeMillis);
    } else {
        RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
    }
    return sent;
}



线程如何处理MessageQueue中接收的消息：在Looper的loop函数中循环取出MessageQueue的接收消息队列中的消息，然后调用 Hander的dispatchMessage函数对消息进行处理，至于如何处理（相应消息）则由用户指定（三个方法，优先级从高到低：Message里面的Callback，一个实现了Runnable接口的对象，其中run函数做处理工作；Handler里面的mCallback指向的一个实现了 Callback接口的对象，里面的handleMessage进行处理；处理消息Handler对象对应的类继承并实现了其中 handleMessage函数，通过这个实现的handleMessage函数处理消息）。

Java代码 复制代码
  1. public void dispatchMessage(Message msg) {   
  2.     if (msg.callback != null) {   
  3.         handleCallback(msg);   
  4.     } else {   
  5.         if (mCallback != null) {   
  6.             if (mCallback.handleMessage(msg)) {   
  7.                 return;   
  8.             }   
  9.         }   
  10.         handleMessage(msg);   
  11.     }   
  12. }  
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}


Runnable说明：Runnable只是一个接口，实现了这个接口的类对应的对象也只是个普通的对象，并不是一个Java中的Thread。Thread类经常使用Runnable，很多人有误解，所以这里澄清一下。


从上可知以下关系图：

其中清理Message是Looper里面的loop函数指把处理过的Message放到Message的Pool里面去，如果里面已经超过最大值10个，则丢弃这个Message对象。

调用Handler是指Looper里面的loop函数从MessageQueue的接收消息队列里面取出消息，然后根据消息指向的Handler对象调用其对应的处理方法。
1.5.代码示例

下面我们会以android实例来展示对应的功能，程序界面于下：

程序代码如下，后面部分有代码说明：

Java代码 复制代码
  1. package com.android.messageexample;   
  2. import android.app.Activity;   
  3. import android.content.Context;   
  4. import android.graphics.Color;   
  5. import android.os.Bundle;   
  6. import android.os.Handler;   
  7. import android.os.Looper;   
  8. import android.os.Message;   
  9. import android.util.Log;   
  10. import android.view.View;   
  11. import android.view.View.OnClickListener;   
  12. import android.widget.Button;   
  13. import android.widget.LinearLayout;   
  14. import android.widget.TextView;   
  15. public class MessageExample extends Activity implements OnClickListener {   
  16.  private final int WC = LinearLayout.LayoutParams.WRAP_CONTENT;   
  17.     private final int FP = LinearLayout.LayoutParams.FILL_PARENT;   
  18.     public TextView tv;   
  19.     private EventHandler mHandler;   
  20.     private Handler mOtherThreadHandler=null;   
  21.     private Button btn, btn2, btn3, btn4, btn5, btn6;   
  22.     private NoLooperThread noLooerThread = null;   
  23.     private OwnLooperThread ownLooperThread = null;   
  24.     private ReceiveMessageThread receiveMessageThread =null;   
  25.     private Context context = null;   
  26.     private final String sTag = "MessageExample";   
  27.     private boolean postRunnable = false;   
  28.     
  29.  /** Called when the activity is first created. */  
  30.  @Override  
  31.     public void onCreate(Bundle savedInstanceState) {   
  32.         super.onCreate(savedInstanceState);   
  33.         context = this.getApplicationContext();   
  34.         LinearLayout layout = new LinearLayout(this);   
  35.         layout.setOrientation(LinearLayout.VERTICAL);   
  36.         btn = new Button(this);   
  37.         btn.setId(101);   
  38.         btn.setText("message from main thread self");   
  39.         btn.setOnClickListener(this);   
  40.         LinearLayout.LayoutParams param =   
  41.             new LinearLayout.LayoutParams(250,50);   
  42.         param.topMargin = 10;   
  43.         layout.addView(btn, param);   
  44.         btn2 = new Button(this);   
  45.         btn2.setId(102);   
  46.         btn2.setText("message from other thread to main thread");   
  47.         btn2.setOnClickListener(this);   
  48.         layout.addView(btn2, param);   
  49.         btn3 = new Button(this);   
  50.         btn3.setId(103);   
  51.         btn3.setText("message to other thread from itself");   
  52.         btn3.setOnClickListener(this);   
  53.         layout.addView(btn3, param);   
  54.         btn4 = new Button(this);   
  55.         btn4.setId(104);   
  56.         btn4.setText("message with Runnable as callback from other thread to main thread");   
  57.         btn4.setOnClickListener(this);   
  58.         layout.addView(btn4, param);   
  59.         btn5 = new Button(this);   
  60.         btn5.setId(105);   
  61.         btn5.setText("main thread's message to other thread");   
  62.         btn5.setOnClickListener(this);   
  63.         layout.addView(btn5, param);   
  64.         btn6 = new Button(this);   
  65.         btn6.setId(106);   
  66.         btn6.setText("exit");   
  67.         btn6.setOnClickListener(this);   
  68.         layout.addView(btn6, param);   
  69.         tv = new TextView(this);   
  70.         tv.setTextColor(Color.WHITE);   
  71.         tv.setText("");   
  72.         LinearLayout.LayoutParams param2 =   
  73.            new LinearLayout.LayoutParams(FP, WC);   
  74.         param2.topMargin = 10;   
  75.         layout.addView(tv, param2);   
  76.         setContentView(layout);        
  77.            
  78.         //主线程要发送消息给other thread， 这里创建那个other thread   
  79.   receiveMessageThread = new ReceiveMessageThread();   
  80.   receiveMessageThread.start();   
  81.     }   
  82.     
  83.  //implement the OnClickListener interface   
  84.  @Override  
  85.  public void onClick(View v) {   
  86.   switch(v.getId()){   
  87.   case 101:   
  88.    //主线程发送消息给自己   
  89.    Looper looper;   
  90.    looper = Looper.myLooper();  //get the Main looper related with the main thread   
  91.    //如果不给任何参数的话会用当前线程对应的Looper(这里就是Main Looper)为Handler里面的成员mLooper赋值   
  92.    mHandler = new EventHandler(looper);    
  93.    //mHandler = new EventHandler();   
  94.    // 清除整个MessageQueue里的消息   
  95.    mHandler.removeMessages(0);   
  96.    String obj = "This main thread's message and received by itself!";   
  97.    //得到Message对象   
  98.    Message m = mHandler.obtainMessage(1, 1, 1, obj);   
  99.    // 将Message对象送入到main thread的MessageQueue里面   
  100.    mHandler.sendMessage(m);   
  101.    break;   
  102.   case 102:       
  103.    //other线程发送消息给主线程   
  104.    postRunnable = false;   
  105.    noLooerThread = new NoLooperThread();   
  106.    noLooerThread.start();   
  107.    break;   
  108.   case 103:     
  109.    //other thread获取它自己发送的消息   
  110.    tv.setText("please look at the error level log for other thread received message");   
  111.    ownLooperThread = new OwnLooperThread();   
  112.    ownLooperThread.start();   
  113.    break;    
  114.   case 104:        
  115.    //other thread通过Post Runnable方式发送消息给主线程   
  116.    postRunnable = true;   
  117.    noLooerThread = new NoLooperThread();   
  118.    noLooerThread.start();   
  119.    break;   
  120.   case 105:        
  121.    //主线程发送消息给other thread   
  122.    if(null!=mOtherThreadHandler){   
  123.     tv.setText("please look at the error level log for other thread received message from main thread");   
  124.     String msgObj = "message from mainThread";   
  125.     Message mainThreadMsg = mOtherThreadHandler.obtainMessage(1, 1, 1, msgObj);   
  126.     mOtherThreadHandler.sendMessage(mainThreadMsg);   
  127.    }   
  128.    break;   
  129.   case 106:   
  130.    finish();   
  131.    break;   
  132.   }   
  133.  }   
  134.  class EventHandler extends Handler   
  135.  {   
  136.   public EventHandler(Looper looper) {   
  137.    super(looper);   
  138.   }   
  139.   public EventHandler() {   
  140.    super();   
  141.   }   
  142.   public void handleMessage(Message msg) {   
  143.    //可以根据msg.what执行不同的处理，这里没有这么做   
  144.    switch(msg.what){   
  145.    case 1:   
  146.     tv.setText((String)msg.obj);   
  147.     break;   
  148.    case 2:   
  149.     tv.setText((String)msg.obj);   
  150.     noLooerThread.stop();   
  151.     break;   
  152.    case 3:   
  153.     //不能在非主线程的线程里面更新UI，所以这里通过Log打印收到的消息   
  154.     Log.e(sTag, (String)msg.obj);   
  155.     ownLooperThread.stop();   
  156.     break;   
  157.    default:   
  158.     //不能在非主线程的线程里面更新UI，所以这里通过Log打印收到的消息   
  159.     Log.e(sTag, (String)msg.obj);   
  160.     break;   
  161.    }   
  162.   }   
  163.  }   
  164.  //NoLooperThread   
  165.  class NoLooperThread extends Thread{   
  166.   private EventHandler mNoLooperThreadHandler;   
  167.   public void run() {   
  168.    Looper myLooper, mainLooper;   
  169.    myLooper = Looper.myLooper();   
  170.    mainLooper = Looper.getMainLooper();    //这是一个static函数   
  171.    String obj;   
  172.    if(myLooper == null){   
  173.     mNoLooperThreadHandler = new EventHandler(mainLooper);   
  174.     obj = "NoLooperThread has no looper and handleMessage function executed in main thread!";   
  175.    }   
  176.    else {   
  177.     mNoLooperThreadHandler = new EventHandler(myLooper);   
  178.     obj = "This is from NoLooperThread self and handleMessage function executed in NoLooperThread!";   
  179.    }   
  180.    mNoLooperThreadHandler.removeMessages(0);   
  181.    if(false == postRunnable){   
  182.     //send message to main thread   
  183.     Message m = mNoLooperThreadHandler.obtainMessage(2, 1, 1, obj);   
  184.     mNoLooperThreadHandler.sendMessage(m);   
  185.     Log.e(sTag, "NoLooperThread id:" + this.getId());   
  186.    }else{   
  187.     //下面new出来的实现了Runnable接口的对象中run函数是在Main Thread中执行，不是在NoLooperThread中执行   
  188.     //注意Runnable是一个接口，它里面的run函数被执行时不会再新建一个线程   
  189.     //您可以在run上加断点然后在eclipse调试中看它在哪个线程中执行   
  190.     mNoLooperThreadHandler.post(new Runnable(){     
  191.      @Override     
  192.      public void run() {     
  193.       tv.setText("update UI through handler post runnalbe mechanism!");   
  194.       noLooerThread.stop();   
  195.      }     
  196.     });     
  197.    }   
  198.   }   
  199.  }   
  200.     
  201.  //OwnLooperThread has his own message queue by execute Looper.prepare();   
  202.  class OwnLooperThread extends Thread{   
  203.   private EventHandler mOwnLooperThreadHandler;   
  204.   public void run() {   
  205.    Looper.prepare();    
  206.    Looper myLooper, mainLooper;   
  207.    myLooper = Looper.myLooper();   
  208.    mainLooper = Looper.getMainLooper();    //这是一个static函数   
  209.    String obj;   
  210.    if(myLooper == null){   
  211.     mOwnLooperThreadHandler = new EventHandler(mainLooper);   
  212.     obj = "OwnLooperThread has no looper and handleMessage function executed in main thread!";   
  213.    }   
  214.    else {   
  215.     mOwnLooperThreadHandler = new EventHandler(myLooper);   
  216.     obj = "This is from OwnLooperThread self and handleMessage function executed in NoLooperThread!";   
  217.    }   
  218.    mOwnLooperThreadHandler.removeMessages(0);   
  219.    //给自己发送消息   
  220.    Message m = mOwnLooperThreadHandler.obtainMessage(3, 1, 1, obj);   
  221.    mOwnLooperThreadHandler.sendMessage(m);   
  222.    Looper.loop();    
  223.   }   
  224.  }   
  225.     
  226.  //ReceiveMessageThread has his own message queue by execute Looper.prepare();   
  227.  class ReceiveMessageThread extends Thread{   
  228.   public void run() {   
  229.    Looper.prepare();   
  230.    mOtherThreadHandler = new Handler(){   
  231.     public void handleMessage(Message msg) {   
  232.      Log.e(sTag, (String)msg.obj);   
  233.     }   
  234.    };   
  235.    Looper.loop();   
  236.   }   
  237.  }   
  238.     
  239. }  
package com.android.messageexample;
import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
public class MessageExample extends Activity implements OnClickListener {
 private final int WC = LinearLayout.LayoutParams.WRAP_CONTENT;
    private final int FP = LinearLayout.LayoutParams.FILL_PARENT;
    public TextView tv;
    private EventHandler mHandler;
    private Handler mOtherThreadHandler=null;
    private Button btn, btn2, btn3, btn4, btn5, btn6;
    private NoLooperThread noLooerThread = null;
    private OwnLooperThread ownLooperThread = null;
    private ReceiveMessageThread receiveMessageThread =null;
    private Context context = null;
    private final String sTag = "MessageExample";
    private boolean postRunnable = false;
 
 /** Called when the activity is first created. */
 @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        context = this.getApplicationContext();
        LinearLayout layout = new LinearLayout(this);
        layout.setOrientation(LinearLayout.VERTICAL);
        btn = new Button(this);
        btn.setId(101);
        btn.setText("message from main thread self");
        btn.setOnClickListener(this);
        LinearLayout.LayoutParams param =
            new LinearLayout.LayoutParams(250,50);
        param.topMargin = 10;
        layout.addView(btn, param);
        btn2 = new Button(this);
        btn2.setId(102);
        btn2.setText("message from other thread to main thread");
        btn2.setOnClickListener(this);
        layout.addView(btn2, param);
        btn3 = new Button(this);
        btn3.setId(103);
        btn3.setText("message to other thread from itself");
        btn3.setOnClickListener(this);
        layout.addView(btn3, param);
        btn4 = new Button(this);
        btn4.setId(104);
        btn4.setText("message with Runnable as callback from other thread to main thread");
        btn4.setOnClickListener(this);
        layout.addView(btn4, param);
        btn5 = new Button(this);
        btn5.setId(105);
        btn5.setText("main thread's message to other thread");
        btn5.setOnClickListener(this);
        layout.addView(btn5, param);
        btn6 = new Button(this);
        btn6.setId(106);
        btn6.setText("exit");
        btn6.setOnClickListener(this);
        layout.addView(btn6, 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);     
        
        //主线程要发送消息给other thread， 这里创建那个other thread
  receiveMessageThread = new ReceiveMessageThread();
  receiveMessageThread.start();
    }
 
 //implement the OnClickListener interface
 @Override
 public void onClick(View v) {
  switch(v.getId()){
  case 101:
   //主线程发送消息给自己
   Looper looper;
   looper = Looper.myLooper();  //get the Main looper related with the main thread
   //如果不给任何参数的话会用当前线程对应的Looper(这里就是Main Looper)为Handler里面的成员mLooper赋值
   mHandler = new EventHandler(looper); 
   //mHandler = new EventHandler();
   // 清除整个MessageQueue里的消息
   mHandler.removeMessages(0);
   String obj = "This main thread's message and received by itself!";
   //得到Message对象
   Message m = mHandler.obtainMessage(1, 1, 1, obj);
   // 将Message对象送入到main thread的MessageQueue里面
   mHandler.sendMessage(m);
   break;
  case 102:    
   //other线程发送消息给主线程
   postRunnable = false;
   noLooerThread = new NoLooperThread();
   noLooerThread.start();
   break;
  case 103:  
   //other thread获取它自己发送的消息
   tv.setText("please look at the error level log for other thread received message");
   ownLooperThread = new OwnLooperThread();
   ownLooperThread.start();
   break; 
  case 104:     
   //other thread通过Post Runnable方式发送消息给主线程
   postRunnable = true;
   noLooerThread = new NoLooperThread();
   noLooerThread.start();
   break;
  case 105:     
   //主线程发送消息给other thread
   if(null!=mOtherThreadHandler){
    tv.setText("please look at the error level log for other thread received message from main thread");
    String msgObj = "message from mainThread";
    Message mainThreadMsg = mOtherThreadHandler.obtainMessage(1, 1, 1, msgObj);
    mOthe

  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      IntentFilter 
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

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

相关推荐

    Android中Message机制的灵活应用（二）

    在本文中，我们将深入探讨“Android中Message机制的灵活应用（二）”这一主题，通过学习如何有效利用Message，提升Android应用的交互性能。 首先，我们需要了解Message的基本概念。Message是Handler类中的一个内部...

    Android的Message机制（Handler、Message、Looper）

    ### Android的Message机制详解 #### 一、概述 在Android开发中，消息机制是一个非常重要的概念，它由多个核心组件组成，包括`Handler`、`Message`、`Looper`等。这一机制支持了应用程序内部以及应用程序间的通信。...

    Android中的Message机制

    通过以上介绍可以看出，Android的Message机制是一种非常灵活高效的线程间通信机制。它利用`Handler`、`Message`和`Looper`三个核心组件实现了消息的发送、处理以及线程间的调度。开发者可以通过合理设计和使用这些...

    Android应用源码之HandlerMessage1_HandlerMessage.zip

    在Android应用开发中，HandlerMessage1_HandlerMessage是一个关键的主题，涉及到Android系统中的消息处理机制，尤其是Handler、Message和Looper的使用。这些组件是Android异步编程的重要组成部分，用于解决UI线程与...

    Android handler message奇怪用法详解

    在Android开发中，多线程消息处理机制...当然，实际应用中应根据项目需求和性能考虑选择最合适的解决方案。在进行多线程编程时，理解这些"奇葩"用法不仅能提升代码质量，还能避免潜在的问题，确保应用的稳定性和性能。

    Android 事件处理机制

    在Android系统中，事件处理机制是用户界面交互的关键部分，它允许应用程序响应用户的输入操作，如点击、滑动等。Android事件处理主要包括两种方式：基于监听器（Listener）的事件处理和基于消息队列（Message Queue...

    从现实生活中理解android线程消息机制.pdf

    在Android系统中，线程消息机制是一个至关重要的概念，它关乎着应用程序的性能与响应性。本文将通过日常生活中的例子，帮助我们更好地理解和掌握这一机制。 首先，我们可以将消息队列想象成一个隧道，每一辆汽车...

    AndroidBinder机制总结[归纳].pdf

    在Android系统中，Binder机制是实现进程间通信（IPC）的核心工具，尤其在跨应用程序组件交互时至关重要。本文将深入探讨Android Binder机制及其在组件化思想中的应用。 1. Android组件化思想 Android应用的组件化...

    Android应用开发中多任务机制剖析.pdf

    【Android应用开发中多任务机制剖析】 Android操作系统以其开放性和灵活性深受开发者喜爱，尤其是在应用开发领域。Android系统支持多任务处理，确保用户可以在同一时间执行多个应用程序或在单个应用程序中进行多项...

    Android应用框架原理与程序设计.rar

    2. **Activity管理**：Activity是Android应用中的一个基本组件，代表用户可见的界面。它负责处理用户的交互，并与其他Activity进行通信。理解Activity的生命周期、启动模式以及Intent机制对于开发高效的应用至关重要...

    android中的Handler和Callback机制.pdf

    Android 中的 Handler 和 Callback 机制是 Android 应用程序中的一种重要机制，用于线程之间的通信和消息传递。Handler 是 Android 中的一种机制，用于在线程之间传递消息，主要用来在线程中和 Activity 或 Service ...

    Android应用开发完全自学手册_光盘资料

    10. **通知与消息**：Android的通知系统允许应用在状态栏显示消息，而Message和Handler机制则用于在不同线程间传递数据和控制流程。 11. **网络编程**：Android应用可以使用HttpURLConnection、OkHttp或Retrofit等...

    试析Android异步通信机制.pdf

    在实际应用中，开发者应根据任务的性质和需求选择合适的异步通信机制。例如，对于简单的后台操作，AsyncTask可能是最佳选择；而对于需要长时间运行的任务，IntentService或ThreadPoolExecutor可能更为合适。同时，...

    Android应用程序消息处理机制(Looper、Handler)分析[收集].pdf

    总的来说，Android的消息处理机制是一个高效、灵活的工具，它使得开发者能够优雅地处理异步事件和线程间的通信，是构建高性能Android应用的基础。通过对Looper、Handler和Message的深入理解，开发者可以更好地掌控...

    Android和H5互调

    在现代移动应用开发中，Android和H5（HTML5）的结合使用十分常见。这种混合式开发模式可以充分利用两者的优势，比如Android的原生性能和H5的...在实际应用中，应考虑安全性、兼容性等因素，确保代码的稳定性和可靠性。

    android多线程技术的应用

    在Android应用开发中，多线程技术扮演着至关重要的角色，因为这直接影响到程序的运行流畅性和用户体验。Android系统默认情况下，程序在一个主线程中运行，如果某个任务执行时间过长，会导致主线程阻塞，使得用户界面...

    Android Handler机制实例

    在Android应用开发中，Handler是实现线程间通信的关键组件，尤其在处理UI更新和异步任务时。本文将深入探讨Android Handler机制的实例，帮助初学者理解并掌握这一核心概念。 首先，我们要理解Android应用的基本运行...

    Android软件开发之应用程序之间的通信介绍源码

    在Android软件开发中，应用程序之间的通信（Inter-Process Communication，简称IPC）是一项核心技能，它允许不同的应用之间共享数据和功能。"Android软件开发之应用程序之间的通信介绍源码"是针对这一主题的一个学习...

    Android开发中的多线程编程技术

    在Android应用开发中，多线程技术是必不可少的，它能帮助开发者实现高效的代码执行，提升用户体验，并确保应用程序的响应性。本资源包主要聚焦于Android平台上的多线程编程，包括理论概念、最佳实践以及实际应用案例...

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