Android 中消息模型的四大核心对象:Message、MessageQueue、Looper、Handler

转载 2015年11月20日 23:37:06

一,相关概念

在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()

我们可以看下源码:

[java] view plaincopy
  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的构造方法:

[java] view plaincopy
  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()

[java] view plaincopy
  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个形态不一的构造函数:

[java] view plaincopy
  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源代码,可以发现它的作用就是提供一系列函数,方便我们完成消息的创建封装和插入到消息队列:

[java] view plaincopy
  1. //查看消息队列中是否有存货  
  2.   public final boolean hasMessages(int what) {  
  3.         return mQueue.removeMessages(this, what, nullfalse);  
  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进去:

[java] view plaincopy
  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:

[java] view plaincopy
  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,主线程给自己发消息

[java] view plaincopy
  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,其他线程给主线程发消息

[java] view plaincopy
  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,主线程给其他线程发消息

[java] view plaincopy
  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,其他线程给其自己发消息

[java] view plaincopy
  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.     }  

  1. </span>  

Android 异步消息处理机制 Handler、Looper、Message、MessageQueue之藕断丝连

为什么要使用Handler? 为什么在Activity中直接new Handler()一个匿名内部类就直接能sendMessage和handleMessage处理了呢?那么我在子thread中可以吗?...
  • hds2011
  • hds2011
  • 2017年04月12日 11:14
  • 352

android消息处理机制学习(一)-Handler,Message,MessageQueue,Looper简介

android消息处理机制,是android当中最重要的话题之一,来看看官方文档的分析(这里都直接粘贴处国内的镜像网站,快捷方便): 一 .Hanler简介: 源码地址:http://wear.tec...

Android消息传递源码理解。Handler,Looper,MessageQueue,Message

Android中消息传递模块差不多看了好几次,虽然每次看的方式都差不多但是还是发觉的到每次看了之后,理解的更清晰一点。 关于这个模块的文章数不胜数,但是最重要的还是自己动手理解一遍更好。 会牵扯到的几...

Android 异步消息机制(Looper、Handler、MessageQueue、Message关系)

Android 异步消息机制,其实就是线程通过Looper建立自己的消息循环机制,MessageQueue是FIFO的消息队列,Looper负责从MessageQueue中取出消息,并且分发到消息指定...

Android消息处理机制(Handler、Looper、MessageQueue与Message)

Android消息处理机制(Handler、Looper、MessageQueue与Message) Android是消息驱动的,实现消息驱动有几个要素: 消息的表示:Message消息队列:...

android消息处理机制学习(三)-Handler,Message,MessageQueue,Looper源码分析

转载自:http://blog.csdn.net/yanbober/article/details/45936145。这篇博主的文章讲解得非常棒,其他也有比较棒的一些文章,大家可以关注一下。 这篇文章...

android的消息处理机制(图+源码分析)——Thread,Looper,MessageQueue,Message,Handler之间的关系

原文参考:http://www.cnblogs.com/codingmyworld/archive/2011/09/12/2174255.html   先看一段非常经典的代码,我们从会这里入手,慢...
  • ihrthk
  • ihrthk
  • 2014年02月28日 20:17
  • 2259

Android消息处理惩罚机制(Handler、Looper、MessageQueue与Message)

Android是消息驱动的,实现消息驱动有几个要素: (1)消息的默示:Message (2)消息队列:MessageQueue (3)消息轮回,用于轮回取出消息进行处理惩罚:Looper ...

Android消息处理机制——Looper,Handler,Message,MessageQueue,Thread

Message:消息,由MessageQueue统一列队,终由Handler处理。 Handler:处理者,负责Message的发送及处理。 MessageQueue:消息队列,用来存放Handl...

Android 消息机制(Handler,Looper,MessageQueue,Message)

android的消息处理有三个核心类:Looper,Handler和Message。其实还有一个Message Queue(消息队列),但是MQ被封装到Looper里面了,Handler扮演了往MQ上...
  • heimabb
  • heimabb
  • 2012年12月26日 11:40
  • 407
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android 中消息模型的四大核心对象:Message、MessageQueue、Looper、Handler
举报原因:
原因补充:

(最多只允许输入30个字)