Handler、Looper消息传递机制

最新推荐文章于 2024-05-12 12:07:57 发布

bobob_

最新推荐文章于 2024-05-12 12:07:57 发布

阅读量993

点赞数

分类专栏： android

本文链接：https://blog.csdn.net/dubo_csdn/article/details/86533445

版权

android 专栏收录该内容

317 篇文章 1 订阅

订阅专栏

一、Handler消息传递机制初步认识：

（一）、引入：

子线程没有办法对UI界面上的内容进行操作，如果操作，将抛出异常：CalledFromWrongThreadException

为了实现子线程中操作UI界面，Android中引入了Handler消息传递机制，目的是打破对主线程的依赖性。

什么是Handler？

handler通俗一点讲就是用来在各个线程之间发送数据的处理对象。在任何线程中，只要获得了另一个线程的handler，则可以通过 handler.sendMessage(message)方法向那个线程发送数据。基于这个机制，我们在处理多线程的时候可以新建一个thread，这个thread拥有UI线程中的一个handler。当thread处理完一些耗时的操作后通过传递过来的handler向UI线程发送数据，由UI线程去更新界面。

主线程：运行所有UI组件，它通过一个消息队列来完成此任务。设备会将用户的每项操作转换为消息，并将它们放入正在运行的消息队列中。主线程位于一个循环中，并处理每条消息。如果任何一个消息用时超过5秒，Android将抛出ANR。所以一个任务用时超过5秒，应该在一个独立线程中完成它，或者延迟处理它，当主线程空闲下来再返回来处理它。

（二）、常用类：（Handler、Looper、Message、MessageQueue）

Message：消息，被传递和处理的数据。其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。
Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等。Handler类的主要作用：（有两个主要作用）1）、在工作线程中发送消息；2）、在主线程中获取、并处理消息。
MessageQueue：消息队列，本质是一个数据结构，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message串联起来，等待Looper的抽取。
Looper：消息泵或循环器，不断从MessageQueue中抽取Message。因此，一个MessageQueue需要一个Looper。
Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

（三）、Handler、Looper、Message、MessageQueue之间的关系：

Looper和MessageQueue一一对应，创建一个Looper的同时，会创建一个MessageQueue；
而Handler与它们的关系，只是简单的聚集关系，即Handler里会引用当前线程里的特定Looper和MessageQueue；
在一个线程中，只能有一个Looper和MessageQueue，但是可以有多个Handler，而且这些Handler可以共享一个Looper和MessageQueue；
Message被存放在 MessageQueue中，一个 MessageQueue中可以包含多个Message对象。

【备注：】

Looper对象用来为一个线程开启一个消息循环，从而操作MessageQueue；

默认情况下，Android创建的线程没有开启消息循环Looper，但是主线程例外。

系统自动为主线程创建Looper对象，开启消息循环；

所以主线程中使用new来创建Handler对象。而子线程中不能直接new来创建Handler对象就会异常。

子线程中创建Handler对象，步骤如下：

Looper.prepare();

Handler handler = new Handler() {

//handlemessage(){}

}

Looper.loop();

（四）、Handler类中常用方法：

handleMessage() 用在主线程中，构造Handler对象时，重写handleMessage()方法。该方法根据工作线程返回的消息标识，来分别执行不同的操作。
sendEmptyMessage() 用在工作线程中，发送空消息。
sendMessage() 用在工作线程中，立即发送消息。

（五）、Message消息类中常用属性：

arg1 用来存放整型数据
arg2 用来存放整型数据
obj 用来存放Object数据
what 用于指定用户自定义的消息代码，这样便于主线程接收后，根据消息代码不同而执行不同的相应操作。

【重点】：使用Message需要注意4点：

1、Message虽然也可以通过new来获取，但是通常使用Message.obtain()或Handler.obtainMessage()方法来从消息池中获得空消息对象，以节省资源；

2、如果一个Message只需要携带简单的int型数据，应优先使用arg1和arg2属性来传递数据，这样比其他方式节省内存；

3、尽可能使用Message.what来标识信息，以便用不同的方式处理Message；

4、如果需要从工作线程返回很多数据信息，可以借助Bundle对象将这些数据集中到一起，然后存放到obj属性中，再返回到主线程。

（六）、示例代码一：【重点】

private Handler handler = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text_main_info = (TextView) findViewById(R.id.text_main_info);
        pDialog = new ProgressDialog(MainActivity.this);
        pDialog.setMessage("Loading...");
        image_main = (ImageView) findViewById(R.id.image_main);

        // 主线程中的handler对象会处理工作线程中发送的Message。根据Message的不同编号进行相应的操作。
        handler = new Handler() {
                public void handleMessage(android.os.Message msg) {
                        // 工作线程中要发送的信息全都被放到了Message对象中，也就是上面的参数msg中。要进行操作就要先取出msg中传递的数据。
                        switch (msg.what) {
                        case 0:
                                // 工作线程发送what为0的信息代表线程开启了。主线程中相应的显示一个进度对话框
                                pDialog.show();
                                break;
                        case 1:
                                // 工作线程发送what为1的信息代表要线程已经将需要的数据加载完毕。本案例中就需要将该数据获取到，显示到指定ImageView控件中即可。
                                image_main.setImageBitmap((Bitmap) msg.obj);
                                break;
                        case 2:
                                // 工作线程发送what为2的信息代表工作线程结束。本案例中，主线程只需要将进度对话框取消即可。
                                pDialog.dismiss();
                                break;
                        }
                }
        };

        new Thread(new Runnable() {
                @Override
                public void run() {
                        // 当工作线程刚开始启动时，希望显示进度对话框，此时让handler发送一个空信息即可。
                        // 当发送这个信息后，主线程会回调handler对象中的handleMessage()方法。handleMessage()方法中
                        // 会根据message的what种类来执行不同的操作。
                        handler.sendEmptyMessage(0);

                        // 工作线程执行访问网络，加载网络图片的任务。
                        byte[] data = HttpClientHelper.loadByteFromURL(urlString);
                        // 工作线程将网络访问获取的字节数组生成Bitmap位图。
                        Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0,
                                        data.length);
                        // 工作线程将要发送给主线程的信息都放到一个Message信息对象中。
                        // 而Message对象的构建建议使用obtain()方法生成，而不建议用new来生成。
                        Message msgMessage = Message.obtain();
                        // 将需要传递到主线程的数据放到Message对象的obj属性中，以便于传递到主线程。
                        msgMessage.obj = bitmap;
                        // Message对象的what属性是为了区别信息种类，而方便主线程中根据这些类别做相应的操作。
                        msgMessage.what = 1;
                        // handler对象携带着Message中的数据返回到主线程
                        handler.sendMessage(msgMessage);

                        // handler再发出一个空信息，目的是告诉主线程工作线程的任务执行完毕。一般主线程会接收到这个消息后，
                        // 将进度对话框关闭
                        handler.sendEmptyMessage(2);
                }
        }).start();
}

（七）、示例代码二：图片定时切换：

1、思路：利用多线程，子线程每隔2秒发送一个消息给主线程，主线程中Handler接收消息，并更新ImageView中的图片。这样就实现了循环切换的动态效果。

handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                case 0:
                        image_main_pic.setImageResource(imageId[position++]);
                        if (position >= imageId.length) {
                                position = 0;
                        }
                        break;
                default:
                        break;
                }
        }
};

// 第一种解决办法：利用Thread和Thread的sleep
// new Thread(new Runnable() {
// @Override
// public void run() {
// while (flag) {
// try {
// Thread.sleep(2000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// handler.sendEmptyMessage(0);
// }
// }
// }).start();

// 第二种解决办法：利用Timer定时器和定时器的schedule()方法。
//schedule()方法中有三个参数：
/*第一个：表示定时任务TimerTask。 TimerTask 类实现了Runnable接口，所以要new  TimerTask()，一定要实现run()方法。
第二个：表示第一次执行前的等待延迟时间；
第三个：表示两次定时任务执行之间的间隔时间。*/
new Timer().schedule(new TimerTask() {
        @Override
        public void run() {
                handler.sendEmptyMessage(0);
                //sendEmptyMessage()方法等同于以下几句话。所以。如果只发送一个what，就可以使用sendEmptyMessage()。这样更简单。
                //Message message = Message.obtain();
                // Message message2 = handler.obtainMessage();
                //message.what = 0;
                //handler.sendMessage(message);
        }
}, 1, 1500);

（八）、示例代码三：打地鼠：

handler = new Handler() {

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

switch (msg.what) {

case 0:

image_main_mouse.setVisibility(View.VISIBLE);

// 获取0-8之间的随机数[0,8)，半闭合区间。目的是随机获取给定的8个坐标位置。

// 获取随机数有两种办法：

// 方法一：

// Math.random()*positionArr.length，注意伪随机数是个半闭合区间。即随机数不可能为positionArr.length

// 方法二：

// new Random().nextInt(positionArr.length);

position = (int) (Math.random() * positionArr.length);

image_main_mouse.setX(positionArr[position][0]);

image_main_mouse.setY(positionArr[position][1]);

break;

default:

break;

}

};

image_main_mouse = (ImageView) findViewById(R.id.image_main_mouse);

new Thread(new Runnable() {

@Override

public void run() {

while (flag) {

try {

// 获取0-500之间的随机数，再加上500，目的是让老鼠出现的间隙时间也随机，最短出现间隙为500毫秒，最长为999毫秒。

Thread.sleep(new Random().nextInt(500) + 500);

} catch (InterruptedException e) {

e.printStackTrace();

}

handler.sendEmptyMessage(0);

}

}).start();

image_main_mouse.setOnTouchListener(new View.OnTouchListener() {

@Override

public boolean onTouch(View v, MotionEvent event) {

image_main_mouse.setVisibility(View.GONE);

return false;

}

});

【备注：】

在案例《打地鼠》中使用到了横竖屏幕切换，请参考以下代码：

关于Android中Activity的横竖屏切换问题可以通过AndroidManifest.xml文件中的Activity来配置：

android:screenOrientation=["unspecified" | "user" | "behind" |"landscape" | "portrait" | "sensor" | "nonsensor"]

screenOrientation 用来指定Activity的在设备上显示的方向，每个值代表如下含义：

"`unspecified`"	默认值由系统来判断显示方向.判定的策略是和设备相关的，所以不同的设备会有不同的显示方向.
"`landscape`"	横屏显示（宽比高要长）
"`portrait`"	竖屏显示(高比宽要长)
"`user`"	用户当前首选的方向
"`behind`"	和该Activity下面的那个Activity的方向一致(在Activity堆栈中的)
"`sensor`"	有物理的感应器来决定。如果用户旋转设备这屏幕会横竖屏切换。
"`nosensor`"	忽略物理感应器，这样就不会随着用户旋转设备而更改了（ "`unspecified`"设置除外）。

二、Handler、Looper源码分析：

（一）、Handler的概念：

Handler是用于发送和处理消息和一个线程的MessageQueue相关联的Runable对象。
每个Handler实例关联到一个单一线程和线程的messagequeue。
当您创建一个Handler,从你创建它的时候开始，它就绑定到创建它的线程以及对应的消息队列，handler将发送消息到消息队列，并处理从消息队列中取出的消息。

Handler的主要用途有两个：

(1)、在将来的某个时刻执行消息或一个runnable；

(2)、为运行在不同线程中的多个任务排队。

主要依靠以下方法来完成消息调度：

post(Runnable)、
postAtTime(Runnable, long)、
postDelayed(Runnable, long)、
sendEmptyMessage(int)、
sendMessage(Message)、
sendMessageAtTime(Message)、
sendMessageDelayed(Message, long)

【备注：】

post方法是当到Runable对象到达就被插入到消息队列；
sendMessage方法允许你把一个包含有信息的Message插入消息队列，它会在Handler的handlerMessage(Message)方法中执行(该方法要求在Handler的子类中实现)。
当Handler post或者send消息的时候，可以在消息队列准备好的时候立刻执行，或者指定一个延迟处理或绝对时间对它进行处理，后两个是实现了timeout、ticks或者其他timing-based的行为。
当你的应用创建一个进程时，其主线程(UI线程)会运行一个消息队列，负责管理优先级最高的应用程序对象(Activity、广播接收器等)和任何他们创建的windows。你也可以创建自己的线程，通过handler与主线程进行通信，在新创建的线程中handler通过调用post或sendMessage方法，将传入的Runnable或者Message插入到消息队列中，并且在适当的时候得到处理。

（二）、Handler的用法：

当你实例化一个Handler的时候可以使用Callback接口来避免写自定义的Handler子类。这里的机制类似与Thread与runable接口的关系。

在Handler里面，子类要处理消息的话必须重写handleMessage()这个方法，因为在handler里面它是个空方法：

（三）、Handler、Looper、Message、MessageQueue消息传递机制源码分析：

A、Handler.java:（3个属性，10个方法）

3个属性：

final MessageQueue mQueue; 封装好的Message被handler发送出去，其实就是放到了MessageQueue消息队列中。
final Looper mLooper; 每个handler都有一个looper为其不断接收消息队列中的消息，并返回给handler。
final Callback mCallback; 被handler接收到的消息要通过Callback接口中的handleMessage()方法来进行处理。

10个方法：

public boolean handleMessage(Message msg); Callback接口中的handleMessage()方法，用来处理返回给handler的消息的。
public final Message obtainMessage() 获取Message对象，其本质还是调用Message类的obtain()方法来获取消息对象。
public final boolean sendMessage(Message msg) 发送消息
public final boolean sendEmptyMessage(int what) 发送只有what属性的消息
public final boolean post(Runnable r) 发送消息
public final boolean postAtTime(Runnable r, long uptimeMillis) 定时发送消息
public final boolean postDelayed(Runnable r, long delayMillis) 延迟发送消息
public void dispatchMessage(Message msg) 分发消息。当Looper循环接收消息队列中的消息时，就在不断调用handler的分发消息方法，从而触发Callback接口中的消息处理方法handleMessage()来对消息进行处理。
public final boolean sendMessageDelayed(Message msg, long delayMillis) sendMessage()就是在调用延时发送消息的方法。
public boolean sendMessageAtTime(Message msg, long uptimeMillis) 延时发送消息的方法就是在调用定时发送消息的方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) 将消息压入消息队列中

B、MessageQueue.JAVA:（1个方法）

final boolean enqueueMessage(Message msg, long when) handler发送的消息正是通过该方法被加进了消息队列中。因为消息队列中有消息，从而触发了Looper通过loop()方法循环接收所有的消息。

C、Looper.JAVA:（3个属性，5个方法）

3个属性：

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); 正是由于该线程本地变量，保证了一个线程中只能保存一个Looper对象，也就是说一个Thread中只能有一个Looper对象。
final MessageQueue mQueue; 正是由于MessagQueue中的消息，才触发了Looper的loop()方法。
private static Looper mMainLooper = null; 该属性是主线程中自动创建的Looper对象。

5个方法：

public static void prepare() 每个handler所在的线程都必须有一个Looper提前准备好。
public static void prepareMainLooper() 主线程中的的Looper已经被自动准备好。而该方法不需要手工调用。
public static Looper getMainLooper() 获取主线程中的Looper对象
public static void loop() Looper的作用就是循环接收消息队列中的消息。该方法中执行了一个无限循环。
public static Looper myLooper() 该方法的作用是从线程本地变量中获取到当前线程的Looper对象。

D、Message.java:（10个属性，7个方法）

10个属性：

public int what; 该属性一般用来标识消息执行的状态。
public int arg1; 用来存放整型数据的属性。
public int arg2; 用来存放整型数据的属性。
public Object obj; 用来存放复杂消息数据的属性。
Bundle data; 用来存放复杂消息数据的属性。
Handler target; 标识该消息要被发送给哪个Handler对象。
Message sPool; 消息池对象。
int sPoolSize; 记录消息池中剩余消息的数量。
int MAX_POOL_SIZE=50; 消息池中最大消息数量。
Messenger replyTo; 定义消息的信使对象，将来可以用于跨APP的消息传递。

7个方法：

public static Message obtain() 从消息池中获取消息对象。
public void recycle() 往消息池中归还消息对象。
public void setTarget(Handler target) 给消息设置接收该消息的目标handler对象。
public Handler getTarget() 获取消息的接收handler对象。
public void sendToTarget() 将消息发送到目标handler对象。其本质是调用handler对象的sendMessage()方法来发送当前消息对象。
public void setData(Bundle data) 将Bundle对象设置到message对象中Bundle属性中。
public Bundle getData() 从消息对象中获取Bundle属性的数据。

消息传递机制的执行顺序：

bobob_

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Handler、Looper消息传递机制

一、Handler消息传递机制初步认识：（一）、引入：子线程没有办法对UI界面上的内容进行操作，如果操作，将抛出异常：CalledFromWrongThreadException为了实现子线程中操作UI界面，Android中引入了Handler消息传递机制，目的是打破对主线程的依赖性。什么是Handler？ handler通俗一...
复制链接

扫一扫

专栏目录