Handler、Looper消息传递机制

一、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）

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

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


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

【备注：】

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

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

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

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

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

Looper.prepare();

Handler handler = new Handler() {

//handlemessage(){}

}

Looper.loop();

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

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

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

  1. arg1     用来存放整型数据
  2. arg2      用来存放整型数据
  3. obj        用来存放Object数据
  4. 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的概念：

  1. Handler是用于发送和处理消息和一个线程的MessageQueue相关联的Runable对象。
  2. 每个Handler实例关联到一个单一线程和线程的messagequeue。
  3. 当您创建一个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里面它是个空方法：

（三）、源码分析：

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


3个属性：

    

  • final MessageQueue mQueue;
    • 

  • final Looper mLooper;
    • 

  • final Callback mCallback;
    • 



9个方法：

    

  • public boolean handleMessage(Message msg);
    • 

  • public final Message obtainMessage()
    • 

  • public final boolean sendMessage(Message msg)
    • 

  • public final boolean sendEmptyMessage(int what)
    • 

  • public final boolean post(Runnable r)
    • 

  • public final boolean postAtTime(Runnable r, long uptimeMillis)
    • 

  • public void dispatchMessage(Message msg)
    • 

  • public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    • 

  • public final boolean sendMessageDelayed(Message msg, long delayMillis)
    •

B、Looper.JAVA:（4个属性，4个方法）

每个ThreadLocal中只能有一个Looper，也就是说一个Thread中只有一个Looper

4个属性：

    

  • static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    • 

  • final MessageQueue  mQueue;
    • 

  • final Thread  mThread;
    • 

  • private static Looper mMainLooper = null;
    • 



4个方法：

    

  • public static void prepare()
    • 

  • public static void prepareMainLooper()
    • 

  • public static void loop()
    • 

  • public static Looper myLooper()
    •

C、Message.java:（8个属性，5个方法）


8个属性：

    

  • public int what;
    • 

  • public int arg1;
    • 

  • public int arg2;
    • 

  • public Object obj;
    • 

  • Handler target;
    • 

  • Message sPool;
    • 

  • int sPoolSize;
    • 

  • int MAX_POOL_SIZE=10;
    • 



5个方法：

    

  • public static Message obtain()
    • 

  • public void recycle()
    • 

  • public void setTarget(Handler target)
    • 

  • public Handler getTarget()
    • 

  • public void sendToTarget()
    •
时间： 2024-10-06 06:35:01

Handler、Looper消息传递机制的相关文章

Android的Handler Looper Message机制应用实例与详解(一)

Android的UI操作不是线程安全的(出于提高性能考虑,避免实现多线程同步等机制所引入的延时),若多个线程同时对UI元素进行操作,可能导致线程安全问题.因此,Android中做了严格的规定:只有UI主线程才能对UI进行设置与操作. 在实际编程中,为了避免UI界面长时间得不到响应而导致的ANR(Application Not Responding)异常,通常将网络访问.复杂运算等一些耗时的操作被放在子线程中执行.这就需要子线程在运行完毕后将结果返回到主线程并通过UI进行显示.在Android中,

Android的Handler Looper Message机制应用实例与详解(二)

上一篇博文给出了Android中基于Handler Looper机制实现线程间通信的两个典型实例.本文将对该机制的基本原理进行较深入的研究.个人认为,学好Android编程最好的老师就是Android的源代码,下面将基于Android-19的源码进行分析,重点阐述分析思路. 要分析Handler Looper机制,自然想到去看Handler类和Looper类的源码(分别位于Handler.java和Looper.java两个文件中).简单阅读两个类的描述后,在Looper类的描述中能找到以下一段

Android Handler消息传递机制详解

1.为什么要用Handler 出于性能优化的考虑,Android UI操作并不是线程安全,如果有多个线程并发操作UI组件,可能导致线程安全问题.可以设想下,如果在一个Activity中有多个线程去更新UI,并且都没有加锁机制,可能会导致什么问题? 界面混乱,如果加锁的话可以避免该问题但又会导致性能下降.因此,Android规定只允许UI线程修改Activity的UI组件.当程序第一次启动时,Android会同时启动一条主线程(Main Thread),主线程主要负责处理与UI相关的事件,比如用户

Android笔记二十五.Android事件Handler消息传递机制

因为Android平台不同意Activity新启动的线程訪问该Activity里的界面控件.这样就会导致新启动的线程无法动态改变界面控件的属性值.但在实际Android应用开发中,尤其是涉及动画的游戏开发中,须要让新启动的线程周期性地改变界面控件的属性值,这就须要借助Handler的消息传递机制实现. 一.Handler类简单介绍 1.功能 Handler类主要有两个作用 (1)在新启动的线程中发送消息; (2)在主线程中获取消息.处理消息.即当须要界面发生变化的时候.在子线程中调用Handle

Android学习之Handler消息传递机制

Android只允许UI线程修改Activity里的UI组件.当Android程序第一次启动时,Android会同时启动一条主线程(Main Thread),主线程主要负责处理与UI相关的事件,如用户的按键事件.屏幕绘图事件,并把相关的事件分发到对应的组件进行处理.所以,主线程通常又被称为UI线程. Android只允许UI线程修改Activity里的UI组件,这样会导致新启动的线程无法动态改变界面组件的属性值.但在实际的Android程序开发中,尤其是涉及动画的游戏开发中,需要让新启动的线程周

我理解的Hanlder--android消息传递机制

每一个学习Android的同学都会觉得Handler是一个神奇的东西,我也一样,开始我以为我懂了Handler的机制,后来发现自己是一知半解,昨天想想,我能否自己实现一个Handler,让子线程与ActivityUI线程通信,如果能够自己实现一个Handler,那必然是对Handler的消息传递机制理解渗透了. 一.引入 Android的UI是单线程控制的,实际上,成功的UI框架都是基于单线程的,多线程的UI框架往往因为解决并发和死锁的艰难而胎死腹中.只有UI线程能控制界面控件,但我们总是希望子

android线程消息传递机制——Looper,Handler,Message

android线程消息传递机制——Looper,Handler,Message 在引入这些概念之前,我们先了解一下引入这些机制的背景. 出于性能优化的考虑,Android的UI操作并不是线程安全的(如果你不懂什么是线程安全,可以阅读一下<一起探究多进程与多线程>里的数据安全与可重入),这意味着如果有多个线程同时操作某个UI组件,可能导致线程安全问题.为了解决这个问题,Android制定了一条简单的规则:只允许UI线程修改Activity里的UI组件.这个UI线程也通常被我们称为主线程. 在此引

解析Android的 消息传递机制Handler

1. 什么是Handler: Handler 网络释义"操纵者,管理者的"意思,在Android里面用于管理多线程对UI的操作: 2. 为什么会出现Handler: 在Android的设计机制里面,只允许主线程(一个程序第一次启动时所移动的线程,因为此线程主要是完成对UI相关事件的处理,所以也称UI线程) 对UI进行修改等操作,这是一种规则的简化,之所以这样简化是因为Android的UI操作时线程不安全的,为了避免多个线程同时操作UI造成线程安全 问题,才出现了这个简化的规则. 由此以

Android基础入门教程——3.3 Handler消息传递机制浅析

Android基础入门教程--3.3 Handler消息传递机制浅析 标签(空格分隔): Android基础入门教程 本节引言 前两节中我们对Android中的两种事件处理机制进行了学习,关于响应的事件响应就这两种:本节给大家讲解的 是Activity中UI组件中的信息传递Handler,相信很多朋友都知道,Android为了线程安全,并不允许我们在UI线程外操作UI:很多时候我们做界面刷新都需要通过Handler来通知UI组件更新!除了用Handler完成界面更新外,还可以使用runOnUiT