微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

Android学习之异步消息处理机制

分类：Android作者：编程之家AI导航网

 

•前言

　　我们在开发 APP 的过程中，经常需要更新 UI；

　　但是 Android 的 UI 线程是不安全的；

　　如果想更新 UI 线程，必须在进程的主线程中；

　　这里我们引用了异步消息处理机制来解决之一问题。

•异步消息的组成

概念

　　Android 的异步消息处理机制主要由 4 个部分组成：Message、Handler、MessageQueue 和 Looper。

Message

  • Message 是线程之间传递信息的机制
  • 它可以在内部携带少量的信息，用于在不同线程之间交换数据
  • Message 可以用 what、arg1、arg2、obj 字段携带信息
  • 其中 arg1、arg2 主要用于携带整型数据，obj 携带 Object 对象

Handler

  • Handler 是消息的处理者，它主要用于发送和处理消息
  • 发送消息使用 Handle 的  sendMessage() 方法
  • 而发出的消息经过一系列的辗转处理后，最终会传递到 Handler 的  handleMessage() 方法中

MessageQueue

  • MessageQueue 是消息队列的意思，它主要用于存放所有通过 Handler 发送的消息
  • 这部分消息会一直存在于 MessageQeue 中，直至被 Looper 发送至 handleMessage() 处理
  • 每个线程只会有一个 MessageQueue 对象

Looper

  • Looper 是每个 MessageQueue 的消息管家，调用 Looper 中的  loop() 方法后，就会进入到一个无限循环当中
  • 把 MessageQueue 中的消息取出，并传递到 Handle 的  handleMessage()  方法中进行处理
  • 每个线程当中只会有一个 Looper 对象

Thread,Looper 与 Handler 之间的对应关系

  • 1个线程（Thread）只能绑定 1个循环器（Looper），但可以有多个处理者（Handler）

  • 1个循环器（Looper） 可绑定多个处理者（Handler）

  • 1个处理者（Handler） 只能绑定1个1个循环器（Looper）

　　　　

•异步消息的处理流程

文字描述

　　首先需要在主线程中创建一个 Handler 对象，并重写  handleMessage()  方法，我们主要在  handleMessage() 中进行一系列的操作；

　　当子线程中需要进行 UI 更新时，就在子线程中创建一个 Message 对象，并通过 Handler 将这条消息发送出去；

　　经 Handler 发送的消息会被添加到 MessageQueue 中等待被处理；

　　而 Looper 会一直尝试从 MessageQueue 中取出待处理的消息；

　　最后 Looper 会将消息发送到 Handler 的  handleMessage()  方法中进行处理。

　　由于 Handler 是在主线程中创建的，所以此时  handleMessage() 方法中的代码也会在主线程中运行，

　　于是我们就可以安心的进行 UI 更新操作了。

图示

　　一条 Message 经过这样一个流程的辗转调用后，从子线程进入到了主线程，从不能更新 UI 变成了可以更新 UI；

　　接下来们通过代码进一步理解；

通过内部类的方式创建Handler对象

　　新建一个项目，并选择 Empty Activity；

　　这样，Android Studio 为我们自动生成了 MainActivity.java 和 activity_main.xml 文件；

　　在 activity_main.xml 中添加如下代码；

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="default"
        android:textSize="20sp"
        android:textColor="@color/black"/>

</RelativeLayout>

　　在该布局中，我只放置了一个 TextView 控件，并初始化 text 的值为 default；

　　接下来修改 MainActivity.java 中的代码；

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private Handler handler;
    private TextView tv;

    //自定义MyHandler类，继承自Handler类并重写 handleMessage() 方法
    private class MyHandler extends Handler{

        //通过重写 handlerMessage() 方法
        //从而确定更新 UI 的操作
        @Override
        public void handleMessage(@NonNull Message msg) {
            /*
                根据不同线程发送过来的消息，执行不同的 UI 操作
                根据 Message 对象的 what 属性，标识不同的消息
             */
            switch(msg.what){
                case 1:
                    tv.setText("我是线程A");
                    break;
                case 2:
                    tv.setText("我是线程B");
                    break;
                default:
            }
        }
    }

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

        tv = findViewById(R.id.tv);

        //在主线程中创建Handler实例
        handler = new MyHandler();

        //通过继承Thread类实现多线程
        new Thread(){
            @Override
            public void run() {
                try {
                    sleep(2000);
                } catch (InterruptedException e) {
                    e.printstacktrace();
                }
                //创建所需的消息对象
                Message msg = Message.obtain();
                msg.what = 1;//消息标识
                msg.obj = "A";//消息内存存放

                //在工作线程中，通过 Handler 发送消息到消息队列中
                handler.sendMessage(msg);
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    sleep(4000);
                } catch (InterruptedException e) {
                    e.printstacktrace();
                }
                //创建所需的消息对象
                Message msg = Message.obtain();
                msg.what = 2;//消息标识
                msg.obj = "B";//消息内存存放

                //在工作线程中，通过 Handler 发送消息到消息队列中
                handler.sendMessage(msg);
            }
        }.start();
    }
}

代码分析

　　通过继承 Handler 创建了一个 MyHandler 类，并重写了  handlerMessage() 方法；

　　在该方法中通过判断 msg.what 的不同对 TextView 实施不同的操作；

　　在  onCreate() 方法中，创建了 Handler 实例，并通过  new Thread()  来创建子线程；

　　在子线程中通过创建 Message 对象 msg，并通过  handler.sendMessage(msg)  来向主线程发送子线程的意图；

　　最后，在 MyHandler 类中通过  switch()  处理不同的 msg.what；

运行效果

　　

通过匿名内部类的方式创建Handler对象

　　在上述 MainActivity.java 代码中，我们是通过内部类的方式创建了 MyHandler 对象；

　　接下来，我们通过匿名内部类的方式创建 Handler 对象；

　　修改 MainActivity.java 中的代码；

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private Handler handler;
    private TextView tv;

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

        tv = findViewById(R.id.tv);

        //在主线程中创建Handler实例
        handler = new Handler(){
            //通过重写 handlerMessage() 方法
            //从而确定更新 UI 的操作
            @Override
            public void handleMessage(@NonNull Message msg) {
            /*
                根据不同线程发送过来的消息，执行不同的 UI 操作
                根据 Message 对象的 what 属性，标识不同的消息
             */
                switch(msg.what){
                    case 1:
                        tv.setText("我是线程A");
                        break;
                    case 2:
                        tv.setText("我是线程B");
                        break;
                    default:
                }
            }
        };

        //通过继承Thread类实现多线程
        new Thread(){
            @Override
            public void run() {
                try {
                    sleep(2000);
                } catch (InterruptedException e) {
                    e.printstacktrace();
                }
                //创建所需的消息对象
                Message msg = Message.obtain();
                msg.what = 1;//消息标识
                msg.obj = "A";//消息内存存放

                //在工作线程中，通过 Handler 发送消息到消息队列中
                handler.sendMessage(msg);
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    sleep(4000);
                } catch (InterruptedException e) {
                    e.printstacktrace();
                }
                //创建所需的消息对象
                Message msg = Message.obtain();
                msg.what = 2;//消息标识
                msg.obj = "B";//消息内存存放

                //在工作线程中，通过 Handler 发送消息到消息队列中
                handler.sendMessage(msg);
            }
        }.start();
    }
}

　　实现的效果和上面内部类的是一样的；

　　不过，通过匿名内部类的方式创建 Handler 对象的方法被 Android Studio 嫌弃了；

•实战演练

预期效果图

开淦

　　新建一个项目，命名为 Handle，选择 Empty Activity；

　　在 activity_main.xml 中添加如下代码；

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <ImageView
        android:id="@+id/img"
        android:layout_width="164dp"
        android:layout_height="156dp"
        android:layout_centerInParent="true"
        android:src="@drawable/girl_0"/>
    
</RelativeLayout>

　　在该布局中，我添加了一个 ImageView 控件，并使其居中显示；

　　修改 MainActivity.java 中的代码；

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private Handler handler;
    private int[] imgId = new int[]{
            R.drawable.girl_0,
            R.drawable.girl_1,
            R.drawable.girl_2,
            R.drawable.girl_3,
            R.drawable.girl_4,
            R.drawable.girl_5,
            R.drawable.girl_6,
            R.drawable.girl_7,
    };
    private int imgStart = 0;
    private ImageView img;

    private class MyHandler extends Handler{

        @Override
        public void handleMessage(@NonNull Message msg) {
            if(msg.what == 0)
                img.setimageResource(imgId[imgStart++%8]);
        }
    }

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

        img = (ImageView) findViewById(R.id.img);
        handler = new MyHandler();

        new Thread(){

            @Override
            public void run() {

                while(true){
                    try {
                        sleep(500);
                    } catch (InterruptedException e) {
                        e.printstacktrace();
                    }
                    handler.sendEmptyMessage(0);
                }
            }
        }.start();
    }
}

分析

　　在该代码中，通过定义整型数组 imgId 来存储帧动画素材，并通过内部类来创建 Handler 对象；

　　在新建的线程  new Thread()  中重写了  run() 方法；

　　并在该方法中通过  while(true)  中的  handler.sendEmptyMessage(0)  方法每隔 500毫秒 让 handler 发送一个空信息；

　　以此来实现帧动画的特效；

　　这样，就效果图中的效果就实现了；

　　需要注意的是，一定要添加  sleep()  方法，并且至少要让子线程休眠 1ms；

　　当然，也可以通过使用定时器实现每隔 500毫秒 发送一个空消息的效果；

　　修改 MainActivity.java 中的代码；

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private Handler handler;
    private int[] imgId = new int[]{
            R.drawable.girl_0,
            R.drawable.girl_1,
            R.drawable.girl_2,
            R.drawable.girl_3,
            R.drawable.girl_4,
            R.drawable.girl_5,
            R.drawable.girl_6,
            R.drawable.girl_7,
    };
    private int imgStart = 0;
    private ImageView img;

    private class MyHandler extends Handler{

        @Override
        public void handleMessage(@NonNull Message msg) {
            if(msg.what == 0)
                img.setimageResource(imgId[imgStart++%8]);
        }
    }

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

        img = (ImageView) findViewById(R.id.img);
        handler = new MyHandler();

        //使用定时器,每隔500毫秒让handler发送一个空信息  
        new Timer().schedule(new TimerTask(){

            @Override
            public void run() {
                handler.sendEmptyMessage(0);
            }
        },0,500);
    }
}

　　该代码的运行效果与上一个的运行效果一样；

•声明

参考资料

　　【异步消息处理机制】

　　【Handler消息传递机制浅析】

　　【Android 异步通信：图文详解Handler机制工作原理】

　　【Android 异步通信：手把手教你使用Handler消息传递机制（含实例Demo）】

　　在此感谢大佬的帮助！

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

Android 性能优化——之控件的优化
Android性能优化——之控件的优化 前面讲了图像的优化，接下来分享一下控件的性能优化，这里主要是面向自定义View的优化。 1、首先先说一下我们在自定义View中可能会犯的3个错误： 1）UselesscallstoonDraw()：我们知道调用View.invalidate()会触发Vi...
android TextView描边
前言 上一篇已经讲了如何实现textView中粗字体效果，里面主要重写了onDraw方法。 这一边讲一个进阶功能，实现textView的描边效果。 上效果图。 上代码： 原理讲解： 效果实现思路是：因为系统api只给paint设置strokewidth方法，却没有提供设置描边的色值的方法，而且我们通
GreenDao教程1
最近项目重构，涉及到了数据库和文件下载，发现GreenDao这个框架还是不错的。直接面向对象的，可以通过对对象的操作，实现数据的存储。 但是官网上的API是在不敢恭维，文档写的很糙，看了半天，才搞懂一系列的流程。在此进行一下纪念。免得那天需要修改的时候，一脸懵逼。直接上干货 官网地址：http://
WebView加载页面的两种方式——网络页面和本地页面
WebView加载页面的两种方式 一、加载网络页面 加载网络页面，是最简单的一种方式，只需要传入http的URL就可以，实现WebView加载网络页面 代码如下图： 二、加载本地页面 1、加载assets目录下的HTML页面： 加载assets目录的页面，大多数可以用来做页面数据的存储打包，这样可以
Android 全局使用第三方字体
给APP全局设置字体主要分为两个方面来介绍 一、给原生界面设置第三方字体 1、准备工作-下载第三方字体：传送门 将文件放入工程assets目录下。（一般个人习惯单独命名一个文件夹放字体文件，也可直接放入根目录，但记得改引用路径） 2、代码实现 a、自定义application，将第三方的字体，替换当
Android中粗字体
前言 最近UI大牛出了一版新的效果图，按照IOS的效果做的，页面里面有普通字体、中粗字体、加粗字体。对于IOS的小伙伴，分分钟搞定，但是对于Android开发的我，瞬间懵逼了。WTF！ 安卓只有粗和不粗呀，哪有中粗这回事。硬着头皮做出来一版之后，看到UI嫌弃的表情。深深的刺痛了我的完美心。说啥也要搞
TabLayout基本使用
前言 Tablayout继承自HorizontalScrollView，可以用作顶部标签效果、底部导航栏效果。一般多与ViewPager一起使用。 想直接了解如何实现短下滑效果的请看：TabLayout的高级用法 首先上几个效果图。 图： 使用方法 下面我们来看如何使用， 第一步，先在gradle引
AndroidStudio 各种异常情况处理大法
最近使用AndroidStudio出现了.java文件，显示为xml文件等问题，通过各种采坑之后，发现删除本地的缓存文件这个方法最管用，差不多可以根治95%的莫名其妙的问题。解决办法如下； 先将AS关闭，然后找到你电脑的目录C:\Users\用户名\.AndroidStudio3.5\system\
Android文件各种存储路径的比较
1、File cacheDir = context.getCacheDir(); 应用内部存储空间（数据文件私有）文件存储到这个路径下，不需要申请权限，当应用被卸载的时候，目录下的文件会被删除。 需要注意的是，这个文件的目录和应用的存储位置有关， 当应用被移动到外部存储设备的时候，文件的绝对路径也是
汉诺塔问题
汉诺塔问题 最近面试题遇到过汉诺塔的问题，当时竟然懵逼了，不会了！！大学研究的问题竟然都忘光了，于是抓紧捡起来。然而在网上看了看博客，发现非递归算法还真挺多。下面总结了一下。 一、递归算法 1、递归算法优缺点：递归算法算是最易于理解也是最容易实现的，但是对内存的消耗也是巨大的，因为递归需要系统堆栈来
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native