Android 总结:Message,MessageQueue,Looper,Handler 消息机制

原创 2015年11月20日 02:29:04

一、关键概念

1. Message 消息对象

MessageQueue中的存放的对象,一个MessageQueue中可包含多个Message对象。
通过Message类里的静态方法obtain()可获得Message实例对象:

这里写图片描述

它的创建并不一定是直接创建一个新的实例:

  • 而是先从Message Pool(消息池)中看有没有可用的Message实例,
    存在则直接取出返回这个实例。
  • 如果Message Pool中没有可用的Message实例,
    才用给定的参数创建一个Message对象。
  • 调用removeMessages()时,将Message从Message Queue中删除,同时放入到Message Pool中。

除了上面这种方式,也可以通过Handler对象的obtainMessage()获取一个Message实例。

2. MessageQueue 消息队列

存放消息的地方,每 一个线程最多只可以拥有一个 MessageQueue数据结构。

  1. 通常使用一个Looper对象对该线程的MessageQueue进行管理。
  2. 创建一个线程的时候,一般并不会自动创建其MessageQueue:
    • 主线程创建时,会创建一个默认的Looper对象,而Looper对象的创建,将自动创建一个Message Queue。
    • 其他非主线程,不会自动创建Looper,要需要的时候,通过调用prepare()函数来实现。

3. Looper 消息管理者

每一个MessageQueue都不能脱离Looper而存在,Looper对象的创建是通过prepare()函数来实现的。

  /* This is a typical example of the implementation of a Looper thread, 
  * using the separation of prepare() and loop() 
  * to create an initial Handler to communicate with the Looper. 
  */
  class LooperThread extends Thread {
      public Handler mHandler;

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

每一个Looper对象和一个线程关联,通过调用Looper.myLooper()可以获得当前线程的Looper对象 。

这里写图片描述

Looper从MessageQueue中取出Message然后,交由Handler的handleMessage()进行处理。
处理完成后,调用Message.recycle()将其放入Message Pool中。

4. Handler 消息处理者

Handler负责将需要传递的信息封装成Message 。

  • 通过handler对象的sendMessage()将消息传递给Looper,继而由Looper将Message放入MessageQueue中。
  • 当Looper对象看到MessageQueue中含有Message,就将其广播出去。
    该handler对象收到该消息后,调用handler对象的handleMessage()方法进行处理。

二、线程之间的消息如何进行传递

1. 主线程给自己发送Message

public class MainActivity extends Activity {

    private Button btnTest;
    private TextView textView;

    private Handler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnTest = (Button)this.findViewById(R.id.btn_01);
        textView = (TextView)this.findViewById(R.id.view_01);

        btnTest.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {

                Looper looper = Looper.getMainLooper(); //主线程的Looper对象
                //这里以主线程的Looper对象创建了handler,
                //所以,这个handler发送的Message会被传递给主线程的MessageQueue。
                handler = new MyHandler(looper);
                handler.removeMessages(0);

                //构建Message对象
                //第一个参数:是自己指定的message代号,方便在handler选择性地接收
                //第二三个参数没有什么意义
                //第四个参数需要封装的对象
                Message msg = handler.obtainMessage(1,1,1,"主线程发消息了");

                handler.sendMessage(msg); //发送消息

            }
        });
    }

    class MyHandler extends Handler{

        public MyHandler(Looper looper){
            super(looper);
        }

        public void handleMessage(Message msg){
            super.handleMessage(msg);
            textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
        }
    }
}

2. 其他线程给主线程发送Message

public class MainActivity extends Activity {

    private Button btnTest;
    private TextView textView;

    private Handler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnTest = (Button)this.findViewById(R.id.btn_01);
        textView = (TextView)this.findViewById(R.id.view_01);

        btnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View arg0) {

                //可以看出这里启动了一个线程来操作消息的封装和发送的工作
                //这样原来主线程的发送就变成了其他线程的发送,简单吧?呵呵
                new MyThread().start();    
            }
        });
    }

    class MyHandler extends Handler{
        public MyHandler(Looper looper){
            super(looper);
        }

        public void handleMessage(Message msg){
            super.handleMessage(msg);
            textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
        }
    }

    //加了一个线程类
    class MyThread extends Thread{

        public void run(){
            Looper looper = Looper.getMainLooper(); //主线程的Looper对象
            //这里以主线程的Looper对象创建了handler,
            //所以,这个handler发送的Message会被传递给主线程的MessageQueue。
            handler = new MyHandler(looper);

            //构建Message对象
            //第一个参数:是自己指定的message代号,方便在handler选择性地接收
            //第二三个参数没有什么意义
            //第四个参数需要封装的对象
            Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");

            handler.sendMessage(msg); //发送消息            
        }
    }
}

3. 主线程给其他线程发送Message

public class MainActivity extends Activity {

    private Button btnTest;
    private TextView textView;

    private Handler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnTest = (Button)this.findViewById(R.id.btn_01);
        textView = (TextView)this.findViewById(R.id.view_01);


        //启动线程
        new MyThread().start();    

        btnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View arg0) {
                //这里handler的实例化在线程中
                //线程启动的时候就已经实例化了
                Message msg = handler.obtainMessage(1,1,1,"主线程发送的消息");
                handler.sendMessage(msg);
            }
        });
    }

    class MyHandler extends Handler{
        public MyHandler(Looper looper){
            super(looper);
        }

        public void handleMessage(Message msg){
            super.handleMessage(msg);
            textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
        }
    }

    class MyThread extends Thread{
        public void run(){
            Looper.prepare(); //创建该线程的Looper对象,用于接收消息

            //注意了:这里的handler是定义在主线程中的哦,呵呵,
            //前面看到直接使用了handler对象,是不是在找,在什么地方实例化的呢?
            //现在看到了吧???呵呵,开始的时候实例化不了,因为该线程的Looper对象
            //还不存在呢。现在可以实例化了
            //这里Looper.myLooper()获得的就是该线程的Looper对象了
            handler = new MyThreadHandler(Looper.myLooper());

            //这个方法,有疑惑吗?
            //其实就是一个循环,循环从MessageQueue中取消息。
            //不经常去看看,你怎么知道你有新消息呢???
            Looper.loop(); 

        }

        //定义线程类中的消息处理类
        class MyThreadHandler extends Handler{
            public ThreadHandler(Looper looper){
                super(looper);
            }

            public void handleMessage(Message msg){
                //这里对该线程中的MessageQueue中的Message进行处理
                //这里我们再返回给主线程一个消息
                handler = new MyHandler(Looper.getMainLooper());
                Message msg2 = handler.obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);
                handler.sendMessage(msg2);
            }
        }
    }
}

4. 其他线程给自己发送Message

public class MainActivity extends Activity {

    private Button btnTest;
    private TextView textView;

    private Handler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnTest = (Button)this.findViewById(R.id.btn_01);
        textView = (TextView)this.findViewById(R.id.view_01);

        btnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View arg0) {
                //启动线程
                new MyThread().start();    
            }
        });
    }

    class MyHandler extends Handler{
        public MyHandler(Looper looper){
            super(looper);
        }

        public void handleMessage(Message msg){
            super.handleMessage(msg);
            textView.setText((String)msg.obj);
        }
    }    

    class MyThread extends Thread{
        public void run(){
            Looper.prepare(); //创建该线程的Looper对象
            //这里Looper.myLooper()获得的就是该线程的Looper对象了
            handler = new ThreadHandler(Looper.myLooper());
            Message msg = handler.obtainMessage(1,1,1,"我自己");
            handler.sendMessage(msg);

            Looper.loop(); 
        }

        //定义线程类中的消息处理类
        class ThreadHandler extends Handler{
            public ThreadHandler(Looper looper){
                super(looper);
            }

            public void handleMessage(Message msg){
                //这里对该线程中的MessageQueue中的Message进行处理
                //这里我们再返回给主线程一个消息
                //加入判断看看是不是该线程自己发的信息
                if(msg.what == 1 && msg.obj.equals("我自己")){
                    handler = new MyHandler(Looper.getMainLooper());
                    Message msg2 = handler.obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");
                    handler.sendMessage(msg2);                
                }

            }
        }
    }
}

参考文章:
1. Android 中Message,MessageQueue,Looper,Handler详解+实例

版权声明:本文为博主原创文章,未经博主允许不得转载。

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

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

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

android的消息处理有三个核心类:Looper,Handler和Message。其实还有一个Message Queue(消息队列),但是MQ被封装到Looper里面了,Handler扮演了往MQ上...
  • heimabb
  • heimabb
  • 2012年12月26日 11:40
  • 407

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

Android消息机制

Android 消息机制 - Handler, Looper, Message, MessageQueue 的源码分析

转载请注明本文出自 clevergump 的博客:http://blog.csdn.net/clevergump/article/details/50776596, 谢谢! 一. 前言 Andro...

[Android源代码分析]Android消息机制,Handler,Message,Looper,MessageQueue

最近准备把Android源码大致过一遍,不敢私藏,写出来分享给大家,顺便记录一下自己的学习感悟。里面一定有一些错误的地方,希望广大看客理解理解。 网上也有不少分析文章,这里我尽量分析的更加细致详尽。...

Android中的消息机制(MessageQueue, Looper, Handler)总结

本文最先发布在简书 简书地址:http://www.jianshu.com/p/1f1163f54aa7 背景    最近在使用Handler,想搞清楚他的原理,在网上看了好几篇文章都看的云里雾里的...

深入Android的消息机制源码详解~Handler,MessageQueue与Looper关系

一说到Android的消息机制,自然就会联想到Handler,我们知道Handler是Android消息机制的上层接口,因此我们在开发过程中也只需要和Handler交互即可,很多人认为Handler的...

android的消息机制 handler looper MessageQueue 关系详解

本文参考了 《android开发艺术探索》 很多前辈已经写过类似的文章,我也闲着就加上自己的一些见解写一篇,算是充实下生活,也活动活动自己的大脑。handler对于一个android开发着来说肯定是...

android Handler Looper,MessageQueue消息机制原理

安卓消息处理类: Looper、Handler、MessageQueue、Message、ThreadLocal、ThreadLocal.Values、HandlerThread。 Looper: 线...

Android的消息机制(Handler、Looper、MessageQueue)

注:本文源码基于Android7.0 先大概概括一下消息机制: 这里有三个角色,Handler、looper、MessageQueue。Handler负责发消息和处理消息,Looper负责从Mes...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android 总结:Message,MessageQueue,Looper,Handler 消息机制
举报原因:
原因补充:

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