Android消息处理机制

最新推荐文章于 2022-05-11 11:05:02 发布

zhangzhuowh

最新推荐文章于 2022-05-11 11:05:02 发布

阅读量240

点赞数

分类专栏： Android技术文章标签： android 线程 Handler Runnable Messgae

Android技术专栏收录该内容

3 篇文章 0 订阅

订阅专栏

转载来源：
1. Android–多线程之Handler
2. android的消息处理机制（图+源码分析）——Looper,Handler,Message
3. java线程系列—Runnable和Thread的区别
4. Updating GUI: Runnables vs Messages
5. Handler初探

1. Android消息处理三个核心类

Android消息处理有三个核心类: Looper, Handler和Message 。另外，Message Queue（消息队列）被封装到Looper里面，我们不直接使用MQ，不将其作为核心类。消息处理流程如下图所示：
这里写图片描述

1.1 Looper - 循环线程

每个线程有且最多只能有一个Looper对象，它是一个ThreadLocal；
Looper内部有一个消息队列MQ，loop()方法调用后线程开始不断从队列中取出消息执行；
Looper使一个线程变成Looper线程；
android的主线程也是一个looper线程

使用Looper类创建Looper线程方法如下：

public class LooperThread extends Thread {
    @Override
    public void run() {
        // 将当前线程初始化为Looper线程
        Looper.prepare();

        // ...其他处理，如实例化handler

        // 开始循环处理消息队列
        Looper.loop();
    }
}

1.2 Handler - 消息传递

Class Overview

A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue. Each Handler instance is associated with a single thread and that thread’s message queue. When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it – from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.

Handler，它直接继承自Object，一个Handler允许发送和处理Message或者Runnable对象，并且会关联到主线程的MessageQueue中。每个Handler具有一个单独的线程，并且关联到一个消息队列的线程，就是说一个Handler有一个固有的消息队列。当实例化一个Handler的时候，它就承载在一个线程和消息队列的线程，这个Handler可以把Message或Runnable压入到消息队列，并且从消息队列中取出Message或Runnable，进而操作它们。

Handler主要有两个作用：

在工作线程中发送消息
在UI线程中获取、处理消息

上面介绍到Handler可以把一个Message对象或者Runnable对象压入到消息队列中，进而在UI线程中获取Message或者执行Runnable对象，所以Handler把压入消息队列有两大体系，Post 和 sendMessage：

Post
Post允许把一个Runnable对象入队到消息队列中。它的方法有：
post(Runnable)、postAtTime(Runnable,long)、postDelayed(Runnable,long)。
sendMessage
sendMessage允许把一个包含消息数据的Message对象压入到消息队列中。它的方法有：sendEmptyMessage(int)、sendMessage(Message)、sendMessageAtTime(Message,long)、sendMessageDelayed(Message,long)。
　　从上面的各种方法可以看出，不管是post还是sendMessage都具有多种方法，它们可以设定Runnable对象和Message对象被入队到消息队列中，是立即执行还是延迟执行。

你可能会觉得Handler能发两种消息，一种是Runnable对象，一种是Message对象，这是直观的理解，但其实post发出的Runnable对象最后都被封装成Message对象了，见源码：

// 此方法用于向关联的MQ上发送Runnable对象，它的run方法将在handler关联的looper线程中执行
    public final boolean post(Runnable r)
    {
       // 注意getPostMessage(r)将runnable封装成message
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

    private final Message getPostMessage(Runnable r) {
        Message m = Message.obtain();  //得到空的message
        m.callback = r;  //将runnable设为message的callback，
        return m;
    }

    public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            msg.target = this;  // message的target必须设为该handler！
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

以下作具体说明：

Runnable / Post
　　对于Handler的Post方式来说，它会传递一个Runnable对象到消息队列中，在这个Runnable对象中，重写run()方法。一般在这个run()方法中写入需要在UI线程上的操作。
　　在Handler中，关于Post方式的方法有：

boolean post(Runnable r)：把一个Runnable入队到消息队列中，UI线程从消息队列中取出这个对象后，立即执行。
boolean postAtTime(Runnable r,long uptimeMillis)：把一个Runnable入队到消息队列中，UI线程从消息队列中取出这个对象后，在特定的时间执行。
boolean postDelayed(Runnable r,long delayMillis)：把一个Runnable入队到消息队列中，UI线程从消息队列中取出这个对象后，延迟delayMills秒执行
void removeCallbacks(Runnable r)：从消息队列中移除一个Runnable对象。

下面通过一个Demo，讲解如何通过Handler的post方式在新启动的线程中修改UI组件的属性：

package com.bgxt.datatimepickerdemo;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class HandlerPostActivity1 extends Activity {
    private Button btnMes1,btnMes2;
    private TextView tvMessage;
    // 声明一个Handler对象
    private static Handler handler=new Handler();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.message_activity);        

        btnMes1=(Button)findViewById(R.id.btnMes1);
        btnMes2=(Button)findViewById(R.id.btnMes2);
        tvMessage=(TextView)findViewById(R.id.tvMessage);
        btnMes1.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                // 新启动一个子线程
                new Thread(new Runnable() {                    
                    @Override
                    public void run() {
                        // tvMessage.setText("...");
                        // 以上操作会报错，无法再子线程中访问UI组件，UI组件的属性必须在UI线程中访问
                        // 使用post方式修改UI组件tvMessage的Text属性
                        handler.post(new Runnable() {                    
                            @Override
                            public void run() {
                                tvMessage.setText("使用Handler.post在工作线程中发送一段执行到消息队列中，在主线程中执行。");                        
                            }
                        });                                
                    }
                }).start();
            }
        });

        btnMes2.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {                    
                    @Override
                    public void run() {
                        // 使用postDelayed方式修改UI组件tvMessage的Text属性值
                        // 并且延迟3S执行
                        handler.postDelayed(new Runnable() {

                            @Override
                            public void run() {
                                tvMessage.setText("使用Handler.postDelayed在工作线程中发送一段执行到消息队列中，在主线程中延迟3S执行。");    

                            }
                        }, 3000);                        
                    }
                }).start();

            }
        });
    }
}

这里写图片描述

有一点值得注意的是，对于Post方式而言，它其中Runnable对象的run()方法的代码，均执行在UI线程上，所以对于这段代码而言，不能执行在UI线程上的操作，一样无法使用post方式执行，比如说访问网络，下面提供一个例子，使用post方式从互联网上获取一张图片，并且显示在ImageView中。

package com.bgxt.datatimepickerdemo;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

import android.app.Activity;
import android.app.ProgressDialog;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

public class HandlerPostActivity2 extends Activity {
    private Button btnDown;
    private ImageView ivImage;
    private static String image_path = "http://ww4.sinaimg.cn/bmiddle/786013a5jw1e7akotp4bcj20c80i3aao.jpg";
    private ProgressDialog dialog;
    // 一个静态的Handler，Handler建议声明为静态的
    private static  Handler handler=new Handler();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.asynctask_activity);

        btnDown = (Button) findViewById(R.id.btnDown);
        ivImage = (ImageView) findViewById(R.id.ivSinaImage);

        dialog = new ProgressDialog(this);
        dialog.setTitle("提示");
        dialog.setMessage("正在下载，请稍后...");
        dialog.setCancelable(false);

        btnDown.setOnClickListener(new View.OnClickListener() {            
            @Override
            public void onClick(View v) {
                // 开启一个子线程，用于下载图片
                new Thread(new MyThread()).start();
                // 显示对话框
                dialog.show();
            }
        });
    }

    public class MyThread implements Runnable {

        @Override
        public void run() {
            // 下载一个图片
            HttpClient httpClient = new DefaultHttpClient();
            HttpGet httpGet = new HttpGet(image_path);
            HttpResponse httpResponse = null;
            try {
                httpResponse = httpClient.execute(httpGet);
                if (httpResponse.getStatusLine().getStatusCode() == 200) {
                    byte[] data = EntityUtils.toByteArray(httpResponse
                            .getEntity());
                    // 得到一个Bitmap对象，并且为了使其在post内部可以访问，必须声明为final
                    final Bitmap bmp=BitmapFactory.decodeByteArray(data, 0, data.length);
                    handler.post(new Runnable() {                        
                        @Override
                        public void run() {
                            // 在Post中操作UI组件ImageView
                            ivImage.setImageBitmap(bmp);
                        }
                    });
                    // 隐藏对话框
                    dialog.dismiss();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
}

效果如下：
这里写图片描述

Message
见 1.3 Message

1.3 Message- 消息传递

由上可知，Handler发出的两种消息：Runnable和Message，Runnable对象最后都被封装成Message对象。

Handler如果使用sendMessage的方式把消息入队到消息队列中，需要传递一个Message对象，而在Handler中，需要重写handleMessage()方法，用于获取工作线程传递过来的消息，此方法运行在UI线程上。下面先介绍一下Message。
　　Message是一个final类，所以不可被继承。Message封装了线程中传递的消息，如果对于一般的数据，Message提供了getData()和setData()方法来获取与设置数据，其中操作的数据是一个Bundle对象，这个Bundle对象提供一系列的getXxx()和setXxx()方法用于传递基本数据类型的键值对，对于基本数据类型，使用起来很简单，这里不再详细讲解。而对于复杂的数据类型，如一个对象的传递就要相对复杂一些。在Bundle中提供了两个方法，专门用来传递对象的，但是这两个方法也有相应的限制，需要实现特定的接口，当然，一些Android自带的类，其实已经实现了这两个接口中的某一个，可以直接使用。方法如下：

putParcelable(String key,Parcelable value)：需要传递的对象类实现Parcelable接口。
putSerializable(String key,Serializable value)：需要传递的对象类实现Serializable接口。

还有另外一种方式在Message中传递对象，那就是使用Message自带的obj属性传值，它是一个Object类型，所以可以传递任意类型的对象，Message自带的有如下几个属性：

int arg1：参数一，用于传递不复杂的数据，复杂数据使用setData()传递。
int arg2：参数二，用于传递不复杂的数据，复杂数据使用setData()传递。
Object obj：传递一个任意的对象。
int what：定义的消息码，一般用于设定消息的标志。
　　对于Message对象，一般并不推荐直接使用它的构造方法得到，而是建议通过使用Message.obtain()这个静态的方法或者Handler.obtainMessage()获取。Message.obtain()会从消息池中获取一个Message对象，如果消息池中是空的，才会使用构造方法实例化一个新Message，这样有利于消息资源的利用。并不需要担心消息池中的消息过多，它是有上限的，上限为10个。Handler.obtainMessage()具有多个重载方法，如果查看源码，会发现其实Handler.obtainMessage()在内部也是调用的Message.obtain()。

2. `Runnables` vs `Messages`

Stackoverflow: Updating-GUI: Runnables-vs-Messages
Messages can be reused, so it results in fewer objects created and less GC. You also end up with fewer classes and anonymous types.

One big advantage is that a class sending a Message to a Handler doesn’t need to know anything about the implementation of that Message. That can aid in encapsulation depending on where it’s used.

Lastly consider the difference in cleanliness between

mHandler.obtainMessage(DO_STUFF, foo).sendToTarget();

final Foo tempFoo = foo;
mHandler.post(new Runnable(){
    @Override
    public void run(){
        doStuff(tempFoo);
    }
};

If you have several places where you would have to doStuff(), the former is MUCH more readable and you’ll have less code duplication.
　　

zhangzhuowh

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android消息处理机制

1、Android 消息处理机制研究；2、Handle详解；3、Runnable和Message对比；
复制链接

扫一扫

专栏目录