Message的细枝末节,深远驾驭之

之前说了Android消息分发和多线程切换的核心知识点,这次来说一下消息传递的整个过程,好像上一篇内容不看貌似也可以直接看这篇,不过建议还是看一下可以了解的更透彻一点吧~~

深入理解之 Android Handler

 

一,相关概念

在Android中如果通过用户界面(如button)来来启动线程,然后再线程中的执行代码将状态信息输出到用户界面(如文本框),这时候就会抛出以下的异常信息:

5-12 13:33:04.393: ERROR/JavaBinder(1029):android.view.ViewRoot$CalledFromWrongThreadException:Onlythe original thread that created a view hierarchy can touch its views.

该异常的意思是,只有最初创建视图层次结构的线程才能接触该结构中的视图,也就是说,不是最初创建界面的线程是不能接触界面元素的。那么,在不是创建界面的线程中,如何把内容输出到界面元素中呢?

对了,我们可以通过线程消息分发机制来实现。就应用程序而言,Android系统中Java的应用程序和其他系统上一样,都是依赖于消息驱动完成那些比较有难度的工作,它们的工作原理大致是分别有一个消息队列负责接收各种消息,一个消息循环可以不断从中取出消息然后做处理。先了解一下几个消息机制的常见名词概念:

 

 

  • Handler

 

消息的封装者和处理者,handler负责将需要传递的信息封装成Message,通过调用handler对象的obtainMessage()来实现;将消息传递给Looper,这是通过handler对象的sendMessage()来实现的。继而由Looper将Message放入MessageQueue中。当Looper对象看到MessageQueue中含有Message,就将其广播出去。该handler对象收到该消息后,调用相应的handler对象的handleMessage()方法对其进行处理。

 

  • Message

 

消息对象,Message Queue中的存放的对象。一个Message Queue中包含多个Message。Message实例对象的取得,通常使用Message类里的静态方法obtain(),该方法有多个重载版本可供选择;它的创建并不一定是直接创建一个新的实例,而是先从Message Pool(消息池)中看有没有可用的Message实例,存在则直接取出返回这个实例。如果Message Pool中没有可用的Message实例,则才用给定的参数创建一个Message对象。调用removeMessages()时,将Message从Message Queue中删除,同时放入到Message Pool中。除了上面这种方式,也可以通过Handler对象的obtainMessage()获取一个Message实例。

 

  • MessageQueue

 

是一种数据结构,见名知义,就是一个消息队列,存放消息的地方。每一个线程最多只可以拥有一个MessageQueue数据结构。创建一个线程的时候,并不会自动创建其MessageQueue。通常使用一个Looper对象对该线程的MessageQueue进行管理。主线程创建时,会创建一个默认的Looper对象,而Looper对象的创建,将自动创建一个Message Queue。其他非主线程,不会自动创建Looper,要需要的时候,通过调用prepare函数来实现。

 

  • Looper

 

是MessageQueue的管理者。每一个MessageQueue都不能脱离Looper而存在,Looper对象的创建是通过prepare函数来实现的。同时每一个Looper对象和一个线程关联。通过调用Looper.myLooper()可以获得当前线程的Looper对象创建一个Looper对象时,会同时创建一个MessageQueue对象。除了主线程有默认的Looper,其他线程默认是没有MessageQueue对象的,所以,不能接受Message。如需要接受,自己定义一个Looper对象(通过prepare函数),这样该线程就有了自己的Looper对象和MessageQueue数据结构了。Looper从MessageQueue中取出Message然后,交由Handler的handleMessage进行处理。处理完成后,调用Message.recycle()将其放入Message Pool中。

二,Looper类分析

当需要向其他线程发消息时我们需要实例化Looper对象会有以下两步:

1,Looper.prepare()

我们可以看下源码:

  1. // sThreadLocal.get() will return null unless you've called prepare().  
  2.     static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();   
  3. public static void prepare() {   
  4.        if (sThreadLocal.get() != null) {   
  5.            throw new RuntimeException("Only one Looper may be created per thread");   
  6.        }   
  7.  // 构造一个Looper对象,保存到调用线程的局部变量中。  
  8.         sThreadLocal.set(new Looper());   
  9.    }  

可以看出来,Looper.prepare()会在调用线程的局部变量中设置一个Looper对象。这个调用线程就是LooperThread的run线程。F3看一下Looper的构造方法:

  1. private Looper() {  
  2.      //构造一个消息队列  
  3.         mQueue = new MessageQueue();  
  4.         mRun = true;  
  5.      //获取当前线程的Thread对象  
  6.         mThread = Thread.currentThread();  
  7.     }  

所以Looper.prepare()的作用是设置一个Looper对象保存在sThreadLocal里,而Looper自己内部封装了一个消息队列。就这样把Looper和调用线程关联在一起了。到底要干嘛,我们看Looper的第二步棋

2,Looper.loop()

 

  1. public static void loop() {  
  2.         //myLooper()将会返回保存在sThreadLocal中的Looper对象。  
  3.         Looper me = myLooper();  
  4.         if (me == null) {  
  5.             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
  6.         }  
  7.         //取出该Looper中的消息队列  
  8.         MessageQueue queue = me.mQueue;    
  9.         while (true) {  
  10.             //处理消息,Message对象中有一个target,它是Handle类型  
  11.             Message msg = queue.next(); // might block  
  12.             if (msg != null) {  
  13.                 if (msg.target == null) {  
  14.                     // No target is a magic identifier for the quit message.  
  15.                     return;  
  16.                 }  
  17.                 msg.target.dispatchMessage(msg);  
  18.                 msg.recycle();  
  19.             }  
  20.         }  
  21.     }  
  22.   
  23.     /** 
  24.      * Return the Looper object associated with the current thread.  Returns 
  25.      * null if the calling thread is not associated with a Looper. 
  26.      */  
  27.     public static Looper myLooper() {  
  28.         return sThreadLocal.get();  
  29.     }  

综上可以知道Looper类的作用是:

 

封装了一个消息队列;

Looper的prepare方法把这个Looper和调用prepare的线程绑定在一起;

处理线程调用loop方法,处理来自该消息队列的消息。

三,Handler类分析

1,好多构造函数

一样看去,我们可以看到几个眼熟的家伙:MessageQueue,Looper,Callback,一个不少,他们是干嘛的?往下看发现有4个形态不一的构造函数:

 

  1. /** 
  2.      * 构造函数一,铁板一块,不过也完成了调用线程的Looper,并获得它的消息队列。 
  3.      */  
  4.     public Handler() {  
  5.         mLooper = Looper.myLooper();  
  6.         if (mLooper == null) {  
  7.             throw new RuntimeException(  
  8.                 "Can't create handler inside thread that has not called Looper.prepare()");  
  9.         }  
  10.         mQueue = mLooper.mQueue;  
  11.         mCallback = null;  
  12.     }  
  13.   
  14.     /** 
  15.      * 构造函数二,多了一个callback 
  16.      */  
  17.     public Handler(Callback callback) {  
  18.         mLooper = Looper.myLooper();  
  19.         if (mLooper == null) {  
  20.             throw new RuntimeException(  
  21.                 "Can't create handler inside thread that has not called Looper.prepare()");  
  22.         }  
  23.         mQueue = mLooper.mQueue;  
  24.         mCallback = callback;  
  25.     }  
  26.   
  27.     /** 
  28.      * 构造函数三,Looper由外部传入,定制。 
  29.      */  
  30.     public Handler(Looper looper) {  
  31.         mLooper = looper;  
  32.         mQueue = looper.mQueue;  
  33.         mCallback = null;  
  34.     }  
  35.   
  36.     /** 
  37.      * 构造函数四,它是2和3的结合体。 
  38.      */  
  39.     public Handler(Looper looper, Callback callback) {  
  40.         mLooper = looper;  
  41.         mQueue = looper.mQueue;  
  42.         mCallback = callback;  
  43.     }  

在上面的构造函数中,Handler中的消息队列变量最终都会指向Looper的消息队列,Handler为啥要这么做,我们继续挖。

 

2,Handler的真正使命

通过分析Handler源代码,可以发现它的作用就是提供一系列函数,方便我们完成消息的创建封装和插入到消息队列: 

 

  1. //查看消息队列中是否有存货  
  2.   public final boolean hasMessages(int what) {  
  3.         return mQueue.removeMessages(this, what, null, false);  
  4.     }  
  5. //创建封装一个消息  
  6.   public final Message obtainMessage(int what)  
  7.     {  
  8.         return Message.obtain(this, what);  
  9.     }  
  10. //发送一个消息,并添加到队列尾  
  11.   public final boolean sendMessage(Message msg)  
  12.     {  
  13.         return sendMessageDelayed(msg, 0);  
  14.     }  
  15. //延时发送一个消息,并添加到队列尾  
  16.   public final boolean sendMessageDelayed(Message msg, long delayMillis)  
  17.     {  
  18.         if (delayMillis < 0) {  
  19.             delayMillis = 0;  
  20.         }  
  21.         return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
  22.     }  

选其一进行分析,就sendMessageDelayed()了,F3进去:

 

  1. public boolean sendMessageAtTime(Message msg, long uptimeMillis)  
  2.     {  
  3.         boolean sent = false;  
  4.         MessageQueue queue = mQueue;  
  5.         if (queue != null) {  
  6. //把Message的target设置为自己,然后加入消息队列中  
  7.             msg.target = this;  
  8.             sent = queue.enqueueMessage(msg, uptimeMillis);  
  9.         }  
  10.         else {  
  11.             RuntimeException e = new RuntimeException(  
  12.                 this + " sendMessageAtTime() called with no mQueue");  
  13.             Log.w("Looper", e.getMessage(), e);  
  14.         }  
  15.         return sent;  
  16.     }  

以上工作是往Looper的消息队列中加入了一个消息,按照Looper类分析可知,它在获取消息后会调用target的dispatchMessage函数,再把这个消息分发给Handle处理,接着继续看Handler.java:

 

  1. public void dispatchMessage(Message msg) {  
  2. // 1,如果Message本身有callback,则直接交给Message的callback处理  
  3.         if (msg.callback != null) {  
  4.             handleCallback(msg);  
  5.         } else {  
  6. // 2,如果本Handle设置了mCallback,则交给它处理  
  7.             if (mCallback != null) {  
  8.                 if (mCallback.handleMessage(msg)) {  
  9.                     return;  
  10.                 }  
  11.             }  
  12. // 3,啥也没有,就交给子类来处理  
  13.             handleMessage(msg);  
  14.         }  
  15.     }  

在绝大多数情况下,我们都是走的第三部流程,用一个从Handler派生的子类并重载handleMessage()来处理各种封装的消息。

 

小结:1,Looper中有一个Message队列,里面储存的是一个个待处理的Message。

             2,Message中有一个Handler,这个Handler是用来处理Message的。

四,实战篇

1,主线程给自己发消息

 

  1. <span style="font-family:'Microsoft YaHei';font-size:12px;">public class handler1 extends Activity {  
  2.         private Button btnTest;  
  3.         private EditText textView;  
  4.         private final String tag="hyj_handler1";  
  5.         private Handler handler;  
  6.     /** Called when the activity is first created. */  
  7.     @Override  
  8.     public void onCreate(Bundle savedInstanceState) {  
  9.         super.onCreate(savedInstanceState);  
  10.         setContentView(R.layout.main);  
  11.         btnTest = (Button)this.findViewById(R.id.bt1);  
  12.         textView = (EditText)this.findViewById(R.id.ed1);  
  13.           
  14.         btnTest.setOnClickListener(new View.OnClickListener() {  
  15.               
  16.             @Override  
  17.             public void onClick(View arg0) {  
  18.                   
  19.                 Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
  20.                 //这里以主线程的Looper对象创建了handler,  
  21.                 //所以,这个handler发送的Message会被传递给主线程的MessageQueue。  
  22.                 handler = new MyHandler(looper);  
  23.                 handler.removeMessages(0);  
  24.                 //构建Message对象  
  25.                 //第一个参数:是自己指定的message代号,方便在handler选择性地接收  
  26.                 //第二三个参数没有什么意义  
  27.                 //第四个参数需要封装的对象  
  28.                 Message msg = handler.obtainMessage(1,1,1,"主线程发消息了");  
  29.                   
  30.                 handler.sendMessage(msg); //发送消息  
  31.                 Log.i(tag, looper.toString());  
  32.                 Log.i(tag, msg.toString());  
  33.                 Log.i(tag, handler.toString());  
  34.             }  
  35.         });  
  36.     }  
  37.       
  38.     class MyHandler extends Handler{  
  39.           
  40.         public MyHandler(Looper looper){  
  41.             super(looper);  
  42.         }  
  43.           
  44.         public void handleMessage(Message msg){  
  45.             super.handleMessage(msg);  
  46.             textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  47.         }  
  48.     }  
  49. }</span>  

 

2,其他线程给主线程发消息

 

  1. <span style="font-family:'Microsoft YaHei';font-size:12px;">public class handler2 extends Activity{  
  2.   
  3.         private Button btnTest;  
  4.         private EditText textView;  
  5. //      private final String tag="hyj_handler2";  
  6.         private Handler handler;  
  7.  /** Called when the activity is first created. */  
  8.  @Override  
  9.  public void onCreate(Bundle savedInstanceState) {  
  10.      super.onCreate(savedInstanceState);  
  11.      setContentView(R.layout.layout2);  
  12.      btnTest = (Button)this.findViewById(R.id.bt2);  
  13.      textView = (EditText)this.findViewById(R.id.ed2);  
  14.        
  15.      btnTest.setOnClickListener(new View.OnClickListener() {  
  16.            
  17.          @Override  
  18.          public void onClick(View arg0) {  
  19.                
  20.              //可以看出这里启动了一个线程来操作消息的封装和发送的工作  
  21.              //这样原来主线程的发送就变成了其他线程的发送,简单吧?呵呵  
  22.              new MyThread().start();    
  23.          }  
  24.      });  
  25.  }  
  26.    
  27.  class MyHandler extends Handler{  
  28.        
  29.      public MyHandler(Looper looper){  
  30.          super(looper);  
  31.      }  
  32.        
  33.      public void handleMessage(Message msg){  
  34.          super.handleMessage(msg);  
  35.          textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  36.      }  
  37.  }  
  38.  class MyThread extends Thread{  
  39.        
  40.      public void run(){  
  41.          Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
  42.          //这里以主线程的Looper对象创建了handler,  
  43.          //所以,这个handler发送的Message会被传递给主线程的MessageQueue。  
  44.          handler = new MyHandler(looper);  
  45.          Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");        
  46.          handler.sendMessage(msg); //发送消息              
  47.      }  
  48.  }  
  49. }</span>  

 

3,主线程给其他线程发消息

 

  1. <span style="font-family:'Microsoft YaHei';font-size:12px;">public class handler3 extends Activity{  
  2.     private Button btnTest;  
  3.     private EditText textView;  
  4.       
  5.     private Handler handler;  
  6.       
  7.     @Override  
  8.     public void onCreate(Bundle savedInstanceState) {  
  9.         super.onCreate(savedInstanceState);  
  10.         setContentView(R.layout.main);  
  11.           
  12.         btnTest = (Button)this.findViewById(R.id.bt1);  
  13.         textView = (EditText)this.findViewById(R.id.ed1);  
  14.           
  15.           
  16.         //启动线程  
  17.         new MyThread().start();      
  18.           
  19.         btnTest.setOnClickListener(new View.OnClickListener() {  
  20.               
  21.             @Override  
  22.             public void onClick(View arg0) {  
  23.                 //这里handler的实例化在线程中  
  24.                 //线程启动的时候就已经实例化了  
  25.                 Message msg = handler.obtainMessage(1,1,1,"主线程发送的消息");  
  26.                 handler.sendMessage(msg);  
  27.             }  
  28.         });  
  29.     }  
  30.       
  31.     class MyHandler extends Handler{  
  32.           
  33.         public MyHandler(Looper looper){  
  34.             super(looper);  
  35.         }  
  36.           
  37.         public void handleMessage(Message msg){  
  38.             super.handleMessage(msg);  
  39.             textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  40.         }  
  41.     }  
  42.       
  43.     class MyThread extends Thread{  
  44.           
  45.         public void run(){  
  46.             Looper.prepare(); //创建该线程的Looper对象,用于接收消息  
  47.               
  48.             //注意了:这里的handler是定义在主线程中的哦,呵呵,  
  49.             //前面看到直接使用了handler对象,是不是在找,在什么地方实例化的呢?  
  50.             //现在看到了吧???呵呵,开始的时候实例化不了,因为该线程的Looper对象  
  51.             //还不存在呢。现在可以实例化了  
  52.             //这里Looper.myLooper()获得的就是该线程的Looper对象了  
  53.             handler = new ThreadHandler(Looper.myLooper());  
  54.               
  55.             //这个方法,有疑惑吗?  
  56.             //其实就是一个循环,循环从MessageQueue中取消息。  
  57.             //不经常去看看,你怎么知道你有新消息呢???  
  58.             Looper.loop();   
  59.   
  60.         }  
  61.           
  62.         //定义线程类中的消息处理类  
  63.         class ThreadHandler extends Handler{  
  64.               
  65.             public ThreadHandler(Looper looper){  
  66.                 super(looper);  
  67.             }  
  68.               
  69.             public void handleMessage(Message msg){  
  70.                 //这里对该线程中的MessageQueue中的Message进行处理  
  71.                 //这里我们再返回给主线程一个消息  
  72.                 handler = new MyHandler(Looper.getMainLooper());  
  73.                   
  74.                 Message msg2 = handler.obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);  
  75.                   
  76.                 handler.sendMessage(msg2);  
  77.             }  
  78.         }  
  79.     }</span>  

 

4,其他线程给其自己发消息

 

  1. <span style="font-family:'Microsoft YaHei';font-size:12px;">public class handler4 extends Activity{  
  2.     Button bt1 ;  
  3.     EditText et1;  
  4.     Handler handler;  
  5.     public void onCreate(Bundle savedInstanceState){  
  6.         super.onCreate(savedInstanceState);  
  7.         setContentView(R.layout.main);  
  8.         bt1 = (Button)findViewById(R.id.bt1);  
  9.         et1 = (EditText)findViewById(R.id.ed1);  
  10.           
  11.         bt1.setOnClickListener(new View.OnClickListener() {  
  12.               
  13.             @Override  
  14.             public void onClick(View v) {  
  15.                 new ThreadHandler().start();  
  16.             }  
  17.         });  
  18.           
  19.           
  20.     }  
  21.       
  22. class MyHandler extends Handler{  
  23.           
  24.         public MyHandler(Looper looper){  
  25.             super(looper);  
  26.         }  
  27.           
  28.         public void handleMessage(Message msg){  
  29.             super.handleMessage(msg);  
  30.             et1.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  31.         }  
  32.     }  
  33.       
  34.  public class ThreadHandler extends Thread{  
  35.         public void run(){  
  36.             Looper.prepare();  
  37.             handler = new Handlerthread(Looper.myLooper());  
  38.             Message msg = handler.obtainMessage(1,1,1,"我自己");  
  39.             handler.sendMessage(msg);  
  40.             Looper.loop();  
  41.         }  
  42.           
  43.         //定义线程类中的消息处理类  
  44.        public class Handlerthread extends Handler{     
  45.             public Handlerthread(Looper looper){  
  46.                 super(looper);  
  47.             }  
  48.               
  49.             public void handleMessage(Message msg){  
  50.                 //这里对该线程中的MessageQueue中的Message进行处理  
  51.                 //这里我们再返回给主线程一个消息  
  52.                 //加入判断看看是不是该线程自己发的信息  
  53.                 if(msg.what == 1 && msg.obj.equals("我自己")){  
  54.                     handler = new MyHandler(Looper.getMainLooper());    
  55.                     Message msg2 = handler.obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");          
  56.                     handler.sendMessage(msg2);             
  57.                 //et1.setText("++++++threadhandler"+(String)msg.obj);  
  58.               
  59.         }}  
  60.        }  
  61.           
  62.     }  
  63. </span>

上一篇请看:

下面开始本篇的主题吧,我将按照Handler和Message的一般使用流程,跟着代码调用链一步步往下走,所以,看代码吧!

首先在主线程定义一个handler:

 Handler handler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage; switch { case TEST: handleTest; break; default: handleDefault; break; } } };

然后在工作线程中使用拿到handler的引用,直接使用:

 new Thread(){ @Override public void run() { super.run(); Message message = Message.obtain(); message.what = TEST; Bundle bundle =new Bundle(); bundle.putString("test key","test value"); message.setData; handler.sendMessage; } }.start();

以上即为一个简单使用场景,在工作线程中通过将Message发送到主线程的handler,让handler在主线程中处理UI相关的操作。

我们从第一段代码开始,先看一下Handler的创建过程。很简单,直接new一个Handler对象,然后实现它的handleMessage(Message msg)方法,但是这个handler可不是随便哪里都能创建的,相信很多同学肯定也碰到过在别的线程中创建handler报错的情况,类似Can't create handler inside thread that has not called Looper.prepare()这样的错误提示,为啥呢?

 /** * Default constructor associates this handler with the {@link Looper} for the * current thread. * * If this thread does not have a looper, this handler won't be able to receive messages * so an exception is thrown. */ public Handler() { this(null, false); } public Handler(Callback callback, boolean async) { if (FIND_POTENTIAL_LEAKS) { final Class<? extends Handler> klass = getClass(); if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass && (klass.getModifiers() & Modifier.STATIC) == 0) { Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName; } } mLooper = Looper.myLooper(); if (mLooper == null) { throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare; } mQueue = mLooper.mQueue; mCallback = callback; mAsynchronous = async; } 

最终调用到的构造器中的第一处判断是用来检测内存泄露相关的,我们不管,看mLooper变量的赋值:

 /** * Return the Looper object associated with the current thread. Returns * null if the calling thread is not associated with a Looper. */ public static @Nullable Looper myLooper() { return sThreadLocal.get(); }

sThreadLocal.get()方法上一篇我们讲过了,sThreadLocal是一个全局的静态变量,保存着线程对应的looper对象,get()方法用来获取当前线程对应的looper对象,由于我们这个handler是在主线程中创建的,而主线程在ActivityThreadmain()方法中已经为我们创建了对应的looper对象,因此我们这里去get的话是能取到值的,所以下面一行的判断不会抛异常。但是一般的工作线程,我们如果没用为它创建Looper对象,它是没有对应的Looper对象保存在sThreadLocal中的,因此Looper.myLooper()就会返回null,接下去就会报错,也就是上面说的在工作线程中创建handler会报错的原因。取到mLooper之后,将mLooper中的保存MessageMessageQueue也取出保存在handler的属性mQueue中,然后将构造器的参数callbackasync赋值,我们这里都为null。

这里大致介绍下Handler的几个属性:

  • boolean mAsynchronous:

    这个是用来表明处理Message的时候是否需要保证顺序,默认为false,而且我们其实也没办法去将他设置为true,因为这些构造器都是@hide的,所以我们可以不管它。

  • Callback mCallback:

    这个是Handler的内部接口Callback类型的一个属性,它就一个方法,也叫handleMessage(Message msg),只能在构造器中传参,如果我们在构造器中给了这个参数,那么发送给这个handler的消息将优先会由这个mCallback来执行,不过目前为止我并不清楚哪些场景适用这种方式,知道的同学欢迎指教一下~

  • Looper mLooper:

    handler是用来处理Message的,因此我们必须要有Message来源,而Message的来源MessageQueue是在Looper中的,因此handler需要一个Looper属性。一般情况下mLooper即为主线程或者说是创建它的线程所对应的Looper,但是我们也可以传一个Looper对象给它,关于这个可以看看HandlerThread的相关知识。

  • MessageQueue mQueue:

    没啥好说的,这个就是handler要处理的消息的来源了,它和Looper中的mQueue指向同一个对象。

在看一下Handler的消息分发方法:

 /** * Handle system messages here. */ public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback; } else { if (mCallback != null) { if (mCallback.handleMessage { return; } } handleMessage; } } private static void handleCallback(Message message) { message.callback.run(); }

还记得上一篇中最后线程停留的那个死循环吗,里面有一行代码msg.target.dispatchMessage;,这里每次取出的Message都会被它对应的target也就是Handler对象分发,也就是上面这段代码。

可以看到首先会判断Message对象自己的callback是否为空,它是一个Runnable对象,如果不为空直接调用callbackrun()方法,否则判断handler的属性mCallback是否为空,属性介绍的时候已经讲过这个了,如果不为空则则调用mCallback.handleMessage方法,这个方法返回true就直接return,否则调用handlerhandlerMessage方法,也就是我们要继承Handler要实现的方法,这个是不是有点类似于Android系统的屏幕事件传递机制呢?哈哈~

话说第一篇里有个坑还没填,就是如何在工作线程创建使用Handler,不过相信看到这里的同学应该已经心里有底了吧,参考上一篇中ActivityThread中的main()方法,很容易创建自己的无线循环工作线程了,下面直接给出代码:

 new Thread(){ Handler handler; @Override public void run() { super.run(); Looper.prepare(); handler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage; //handler the message } }; Looper.loop(); } };

以上,即在工作线程中创建了handler,然后将handler的引用丢给别的线程,别的线程就可以通过handler发消息到这个工作线程来处理。

Handler对于消息的分发和处理的逻辑总算说完了,接下去看看Message是如何被送到Handler的。先看下Message的基本信息吧:

  • int what:

    表明消息的类别,handler根据这个字段来判断如何处理这个Message

  • Bundle data:

    用于存放数据,可以存放一些相对复杂的内容,因此开销稍微大一点

  • int arg1,arg2:

    两个基本类型的参数,用于传递一些简单的Message信息,可以的话尽量用这两个参数来传递信息,相对于Bundle data它性能消耗会小很多

  • int flags:

    当前Message状态的一个标志位,类似异步,使用中这些状态

  • long when:

    表示这个Message应该在何时被执行,MessageQueueMessage就是以这个字段为来排序的

  • Handler target:

    Message将要被发送的对象,也就是由哪个target来接受处理这个Message这个字段必须不为null

  • Runnable callback:

    这个讲handler的时候说到过了,如果有这个字段,那么这个Message将由此callback来处理,注意下,它是一个Runnable

  • Message next:

    由于Message在消息池中是链表的形式维护的,所以这个字段表示下一个Message对象

  • static Message sPool:

    这个是静态变量,指向当前消息池的第一个空闲Message

  • static int sPoolSize:

    消息池的大小,也就是剩余空闲Message的数量

  • static final int MAX_POOL_SIZE = 50;

    不用解释了吧?

再贴一下例子中的第二段代码:

 new Thread(){ @Override public void run() { super.run(); Message message = Message.obtain(); message.what = TEST; Bundle bundle =new Bundle(); bundle.putString("test key","test value"); message.setData; handler.sendMessage; } }.start(); 

Message的获取方式特别多,除了自己new一个外,其他基本都大同小异,最终都从Message消息池取一个空闲的Message使用,因为Android系统中到处都用到了Message,因此会需要大量的Message对象,使用消息池的方式可以减少频繁的创建销毁对象,大大的提高性能。我这里直接用最基本的方式获取,Message.obtain();,看源码吧:

 /** * Return a new Message instance from the global pool. Allows us to * avoid allocating new objects in many cases. */ public static Message obtain() { synchronized (sPoolSync) { if (sPool != null) { Message m = sPool; sPool = m.next; m.next = null; m.flags = 0; // clear in-use flag sPoolSize--; return m; } } return new Message(); }

对着上面的字段介绍,很容易看出这个方法的作用就是将消息池的第一个空闲Message拿出来,然后消息池的数量减1,当然如果消息池已经没用空闲Message了,那就new一个返回了。

例子中只用到了whatdata字段,简单给它们赋了值,然后就调用handler.sendMessage;将消息发送给了我们在主线程创建的handler了。

 public final boolean sendMessage(Message msg) { return sendMessageDelayed; } public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); } /** * Enqueue a message into the message queue after all pending messages * before the absolute time (in milliseconds) <var>uptimeMillis</var>. * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b> * Time spent in deep sleep will add an additional delay to execution. * You will receive it in {@link #handleMessage}, in the thread attached * to this handler. * * @param uptimeMillis The absolute time at which the message should be * delivered, using the * {@link android.os.SystemClock#uptimeMillis} time-base. * * @return Returns true if the message was successfully placed in to the * message queue. Returns false on failure, usually because the * looper processing the message queue is exiting. Note that a * result of true does not mean the message will be processed -- if * the looper is quit before the delivery time of the message * occurs then the message will be dropped. */ public boolean sendMessageAtTime(Message msg, long uptimeMillis) { MessageQueue queue = mQueue; if (queue == null) { RuntimeException e = new RuntimeException( this + " sendMessageAtTime() called with no mQueue"); Log.w("Looper", e.getMessage; return false; } return enqueueMessage(queue, msg, uptimeMillis); }

前面两个方法的注释我没贴,因为跟第三个方法内容差不多,而且最终也都是调用第三个方法,所以看了第三个方法的注释和方法体应该很容易明白前两个方法的作用。第一个方法是直接将消息发送handler处理,所以它使用0毫秒的延时作为参数调用第二个方法,第二个方法判断如果延时小于0则默认给0,因为小于0的延迟也就意味着比当前时间早,当然不可能回到过去处理这个消息了,然后它又将当前时间加上延时,调用了第三个方法,这样第三个方法拿到的时间就是一个绝对值了,然后我们看到了mQueue,这个创建handler的时候我们就看到了,指向主线程对应的Looper中的消息队列,最后return了一个方法调用,看名字终于要加入消息队列了。

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous; } return queue.enqueueMessage(msg, uptimeMillis); }

等等,原来我们刚才发送的Message还没对象呢,那啥,我不是说那个对象,正经点儿!所以加入消息队列前先给它一个对象吧!然后如果我们的handler是异步的将msgflag标志位加上成异步,这下msg开开心心地领着对象去排队了~

 //MessageQueue boolean enqueueMessage(Message msg, long when) { if (msg.target == null) { throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse { throw new IllegalStateException(msg + " This message is already in use."); } synchronized  { if (mQuitting) { IllegalStateException e = new IllegalStateException( msg.target + " sending message to a Handler on a dead thread"); Log.w(TAG, e.getMessage; msg.recycle(); return false; } msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { // New head, wake up the event queue if blocked. msg.next = p; mMessages = msg; needWake = mBlocked; } else { // Inserted within the middle of the queue. Usually we don't have to wake // up the event queue unless there is a barrier at the head of the queue // and the message is the earliest asynchronous message in the queue. needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for  { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous { needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next = msg; } // We can assume mPtr != 0 because mQuitting is false. if  { nativeWake; } } return true; }

首先判断Message的对象target是否为空(所以说Message不能没有对象target),然后判断Message是否正在使用中,在经历的前面的入队步骤后,我们这个Message都满足了条件,然后进入一个同步块,首先判断是否正在退出中,因为主线程是不可退出的,所以我们也不用考虑,不过里面方法也是一目了然,回收Message,返回false通知上层入队失败。我们继续看满足条件的情况下,将Message标记为在使用中(msg.markInUse,给when字段赋值,然后创建一个新对象指向消息队列中的第一个消息mMessage,定义了一个布尔类型的字段needWake,表示是否需要唤醒当前线程,因为没有消息需要处理的时候我们的Looper线程是阻塞的。当消息队列中的第一个消息为null或者我们本次需要入队的消息对象msg的when为0或者小于原来的队首消息的when值,则将msg插入到消息队列的队首,也就是mMessage之前,然后mMessage重新指向新的队首,也就是msg;当那些条件不满足的时候,则需要将msg插入到消息队列中而不是队首,插入的方式也很简单除暴,遍历原队列的消息,依次比对when的值,直到队尾或者找到下一个消息的when值比msg的when值大的时候跳出循环,将msg插到其中,这个入队的过程也就完成了,都是一些链表的基本操作。之前也有说到,因为每次有消息进入mQueue,我们都是以这种方式来插入的,所以有序的消息队列就是简单以消息的when的大小来排序的。消息插入到消息队列完成后,判断是否需要唤醒主线程,需要则调用native方法nativeWake()唤醒主线程来处理消息(Message msg = queue.next();//Looper.loop()方法中被唤醒后取出消息并分发处理)。最后返回true表明消息插入队列成功。这样Message入队的过程就算完成了,是不是挺简单的~

以上,就是一个完整的消息传递和分发过程。实际使用中,我们用到更多的可能是handler.post;,handler.postDelayed(runnable,delayMillis);,view.postDelayed(runnable,delayMillis);之类的方法,这些方法看上去好像没有Message什么事,但是点进去一看就发现,这个被post的runnable就是Messagecallback,简单封装一下就又走上了刚刚讲完的消息传递路线,还没反应过来的回头看看handlerdispatchMessage(Message msg)方法,因此这些方式我们都不用重写handleMessage(Message msg)方法,使用起来非常方便。友情提示:非常方便的同时也非常容易导致内存泄露、空指针和其他一些状态紊乱的错误(别问我怎么知道的,死过太多脑细胞

本文由华夏彩票发布于编程应用,转载请注明出处:Message的细枝末节,深远驾驭之

您可能还会对下面的文章感兴趣: