Android基础：异步消息处理机制Handler

最新推荐文章于 2022-11-02 21:04:47 发布

Harlan_Qiu

最新推荐文章于 2022-11-02 21:04:47 发布

阅读量358

点赞数

分类专栏： Android基础文章标签： handler

本文链接：https://blog.csdn.net/q275549832/article/details/76598663

版权

Android基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Android是大量的消息驱动方式来进行交互，Android某种意义上也可以说成是一个以消息驱动的系统。消息机制涉及MessageQueue/Message/Looper/Handler这4个类。
第三方框架的引入让Handler越来越没"用武之地"。然后掌握handler原理以及使用还是很有必要的。。阅读源码、面试装逼必不可少！也是程序员进阶的必经之路。

一、概述

1、定义

Android提供的一套消息机制

2、为什么子线程不允许访问 UI

假若子线程允许访问 UI，则在多线程并发访问情况下，会使得 UI 控件处于不可预期的状态。
传统解决办法：加锁，但会使得UI访问逻辑变的复杂，其次降低 UI 访问的效率。

子线程直接更新UI抛出的异常：

子线程更新UI抛出的异常.png

找到对应源码

ViewRootImol.java
    void checkThread() {
        if (mThread != Thread.currentThread()) {
            throw new CalledFromWrongThreadException(
                    "Only the original thread that created a view hierarchy can touch its views.");
        }
    }

在更新UI的时候都会调用ViewRootImpl的checkThread()方法。
checkThread 方法判断更新UI的线程是否是ViewRootImpl的mThread 线程，不是的话就会抛出异常。

二、相关概念

Message ：分为硬件产生的消息和软件生成的消息
（拥有handler对象）
作用：可以携带少量信息，数据的载体

Message Queue ：消息队列
（队列中拥有N个Message ）
作用：用来存放通过Handler发过来的Message，按照先进先出执行

Looper ：不断循环执行(Looper.loop)，负责循环执行消息
（一个线程拥有一个Looper ，一个Looper拥有Message Queue ）
作用：
1、Looper 所在的线程中循环取出Message Queue的Message，解决多线程并发问题
2、将取出的Message交付给相应的Handler去处理

Handler ：Message的发送者、处理者
（拥有一个线程的线程Looper 和Message Queue 对象）
作用：
1、提供sendMessage方法，将任意线程的消息放置到队列中
2、提供dispatchMessage方法，在Looper 所在的线程处理消息

二、基本流程

1、启动App

App启动后会找ActivityThread main()方法(入口原来在这呢!)

ActivityThread.java
 public static void main(String[] args) {
     ...
     //初始化UI线程的Looper对象
     Looper.prepareMainLooper();
     ...
     //循环处理消息（死循环）
     Looper.loop();
 }

线程调用 Looper.loop()要放在方法的最后面

当在UI线程调用Looper.loop()后、UI线程将处于一个死循环中！所有硬件产生的消息(如按钮、触摸)和软件生成的消息都会被加到死循环中依次执行。
UI线程本身就是个死循环，随时等待着消息的到来。这也是为什么程序启动后任何时间发送的消息UI线程都能够处理的原因。

2、Looper 相关方法：

一个线程只有一个Looper 对象，一个Looper 对象中包含一个Message Queue对象

1、Looper.prepare() 初始化Looper

    private static void prepare(boolean quitAllowed) {
        //sThreadLocal.get()会根据不同线程返回对应的Looper，一线程一个Looper
        if (sThreadLocal.get() != null) {
        //prepare方法调用二次直接抛异常
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

ThreadLocal：线程本地存储区（Thread Local Storage，简称为TLS），每个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。感兴趣的可以看一下它的get和set源码。

2、Looper.loop() 循环处理Message Queue里的Message

public static void loop() {
            ...
            //进入死循环
            for (;;) {
              //next()方法用于取出消息队列里的消息 （可能会阻塞线程）
                Message msg = queue.next(); 
                if (msg == null) {
                    //消息为空退出循环
                    return;
                }
            ...
              //调用对应的handler处理消息
                msg.target.dispatchMessage(msg); 
              //释放消息占据的资源
                msg.recycle();
            }
    }

loop()进入循环模式，不断重复下面的操作，直到没有消息时退出循环

读取MessageQueue的下一条Message；
把Message分发给相应的target(Handler)；
再把分发后的Message回收到消息池 msg.recycle()，以便重复利用。

3、Handler基础用法

3.1 创建Handler对象

Handler的构造方法

    //--------------------------------------------无惨构造方法--------------------------------------------
    public Handler() {
        this(null, false);
    }

    public Handler(Callback callback, boolean async) {
        ...
        //从当前线程的TLS中获取Looper对象
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        //通过Looper获取消息队列
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

    //--------------------------------------------有参数的构造方法--------------------------------------------
    public Handler(Looper looper) {
        this(looper, null, false);
    }

    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

通过构造方法可以发现、handler的创建时需要绑定一个Looper对象的（handler需要绑定在一个线程上，消息处理回调也就在绑定的线程中执行）。一般有2中方式指定绑定的线程：

1. 不指定Looper对象，那么这个Handler绑定到了创建这个线程的线程上，消息处理回调也就在创建线程中执行.
2. 通过Loop.myLooper()得到当前线程的Looper对象/通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。

3.2 通过Handler发送消息

在任意线程中我们可以通过Handler发送消息到Message queue中,发送消息分为sendMessage()和post(Runnable r)2大类：

        ---------------------sendMessage()---------------------
        //发送一个Message
        sendMessage(Message msg)
        //发送一个延迟处理的Message
        sendMessageDelayed(Message msg, long delayMillis)
        //发送一个指定时间处理的Message
        sendMessageAtTime(Message msg, long uptimeMillis) 
        //发送一个优先处理的Message
        sendMessageAtFrontOfQueue(Message msg) 
        sendEmptyMessage(int what)
        sendEmptyMessageDelayed(int what, long delayMillis) 

        ---------------------post(Runnable r)---------------------
        //其实也是发送一个Message
         public final boolean  post(Runnable r){
           return  sendMessageDelayed(getPostMessage(r), 0);
         }
        postDelayed(Runnable r, long delayMillis)
        postAtFrontOfQueue(Runnable r)
        }

源码太多就不贴了，通过源码可以发现

post(Runnable r)其实也是发送一个Message
只有post方式发送的Message才有Runnable，msg.callback 对象才不为空（3.3会用到）
无论是post还是send方式最终都是通过Handler.enqueueMessage()方法把Message添加到MessageQueue中

  private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            //Message.target = 发送它的handler
            msg.target = this;
            //是否异步处理
            if (mAsynchronous) {
                msg.setAsynchronous(true);
               }
            //把Message添加到MessageQueue
            return queue.enqueueMessage(msg, uptimeMillis);
        }

3.3 Handler处理消息

Looper.loop()取出Message会调用msg.target.dispatchMessage(msg)方法msg.target就是Handler

    public void dispatchMessage(Message msg) {
        //msg.callback是一个Runable对象
        //post方式才Message有的Runable
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            //handler构造方法传递的Callback（可选）
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                //屏蔽handleMessage方法
                    return;
                }
            }
            //一般我们重写的handleMessage
            handleMessage(msg);
        }
    }
    public void handleMessage(Message msg) {
    //由开发者重写方法
    }

由上面的代码可以总结出：

post的发送的消息、处理消息时候只会调用post传递的Runable方法
send方式发送的消息可以通过构造方法的Callback方法和重写Handler的 handleMessage处理消息
可以通过构造方法中Callback.handleMessage(msg) 的返回值拦截handleMessage方法

3.4 创建Message

       //1、直接创建
        Message message1 = new Message();
       //2、从消息池复用废弃的Message,这里得到Message已经清空所有的数据
        Message message2 = Message.obtain();

3.5、子线程启动一个消息轮询机制

3.5.1 利用HandlerThread(推荐)

    //1: 创建handlerThread对象
    HandlerThread handlerThread = new HandlerThread("线程名称");
    handlerThread.start();
    
    //2: 创建Handler
    Handler handler = new Handler(handlerThread.getLooper());
    
    //3: 发送消息
    handler.sendEmptyMessage(1);
    ```
**3.5.2 在普通Thread启动**
```java
    class MyThread extends Thread {
        public Handler mHandler;
        public void run() {
            Looper.prepare();
            // 1: 创建Handler
            mHandler = new Handler() {
                public void handleMessage(Message msg) {
                    //TODO  处理即将发送过来的消息
                }
            };
            //放在最后
            Looper.loop();
        }
        }
        //2: 启动LooperThread线程
        MyThread thread = new MyThread();
        thread.start();
        //3: 发送消息
        MyThread.mHandler.sendEmptyMessage(1);
    };

注意：这种方式不要把Handler实例化放在run()方法外面、否则可能Looper.prepare()还没执行就new Handler会导致程序崩溃

三、面试常见问题

问题1：子线更新UI的方式有哪几种？

3.3中的Handler方式更新
runOnUiThread() ------内部也是通过handler发送的
view.post(Runnable)------内部也是通过handler发送的
广播------Binder
EventBus------handler

问题2：子线程一定不能更新UI嘛？

子线程在activity的获取焦点前（onResume之前）方法前可以更新ui（ViewRootImol是在onResume方法中创建的）
surfaceView：可以在子线程中绘制和更新进度
Progress（进度）：相关的控件可以在子线程中更新进度

其实surfaceView Progress 内部也是通过handler去更新进度的

问题3：为什么非UI线程不能跟新UI？
假若子线程允许访问 UI，则在多线程并发访问情况下，会使得 UI 控件处于不可预期的状态。
传统解决办法：加锁，但会使得UI访问逻辑变的复杂，其次降低 UI 访问的效率。
问题4：Looper.loop()是死循环没有导致程序卡死？(见2.1启动App)
异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待。
一句话：程序运行的本身就是在这个死循环中、所以不存在卡死之说。

四、总结

消息发送执行流程图

handler_java.jpg

图片来自于:http://gityuan.com/2015/12/26/handler-message-framework/

Harlan_Qiu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android基础：异步消息处理机制Handler

Android是大量的消息驱动方式来进行交互，Android某种意义上也可以说成是一个以消息驱动的系统。消息机制涉及MessageQueue/Message/Looper/Handler这4个类。第三方框架的引入让Handler越来越没"用武之地"。然后掌握handler原理以及使用还是很有必要的。。阅读源码、面试装逼必不可少！也是程序员进阶的必经之路。一、概述1、定义
复制链接

扫一扫