Android Handler详解

本期主要内容

  • 1: Handler是什么?
  • 2:为什么要使用Handler?
  • 3: Handler /Looper/ MessageQueue/Message究竟是做什么的?
  • 4:Handler如何去实现发送和处理消息

1、Handler是什么?

  • Handler 是一个消息分发对象。handler是Android给我们提供用来更新UI的一套机制,也是一套消息处理机制,我们可以发消息,也可以通过它处理消息。
  • 1:To schedule messages and runnables to be executed as some point in the future 定时任务
  • 2: To enqueue an action to be performed on a different thread than your own 在不同线程中执行任务

2、为什么要使用Handler?

  • 最根本的目的就是为了解决多线程并发的问题!打个比方,如果在一个activity中有多个线程,并且没有加锁,就会出现界面错乱的问题。但是如果对这些更新UI的操作都加锁处理,又会导致性能下降。处于对性能的问题考虑,Android给我们提供这一套更新UI的机制我们只需要遵循这种机制就行了。不用再去关系多线程的问题,所有的更新UI的操作,都是在主线程的消息队列中去轮训的。
  • 它把消息发送给Looper管理的MessageQueue,并负责处理Looper分发给他的消息。

3、Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。那么什么叫异步消息处理线程呢?

Handler 、 Looper 、Message.png
  • 异步消息处理线程启动后会进入一个无限的循环体之中,每循环一次,从其内部的消息队列中取出一个消息,然后回调相应的消息处理函数,执行完成一个消息后则继续循环。若消息队列为空,线程则会阻塞等待。

  • 那么Android消息机制主要是指Handler的运行机制,Handler运行需要底层的MessageQueue和Looper支撑。其中MessageQueue采用的是单链表的结构,Looper可以叫做消息循环。由于MessageQueue只是一个消息存储单元,不能去处理消息,而Looper就是专门来处理消息的,Looper会以无限循环的形式去查找是否有新消息,如果有的话,就处理,否则就一直等待着。

  • 我们知道,Handler创建的时候会采用当前线程的Looper来构造消息循环系统,需要注意的是,线程默认是没有Looper的,如果需要使用Handler就必须为线程创建Looper,因为默认的UI主线程,也就是ActivityThread,ActivityThread被创建的时候就会初始化Looper,这也是在主线程中默认可以使用Handler的原因。

Handler类包含如下方法用于发送、处理消息:

  • void handleMessage(Message msg):处理消息的方法。该方法通常用于被重写。

  • final boolean hasMessages(int what):检查消息队列中是否包含what属性为指定值的消息。

  • final boolean hasMessages(int what, Object object):检查消息队列中是否包含what属性为指定值且object属性为指定对象的消息。

  • 多个重载的Message obtainMessage():获取消息。

  • sendEmptyMessage(int what):发送空消息。

  • final boolean sendEmptyMessageDelayed(int what, long delayMillis):指定多少毫秒后发送空消息。

  • final boolean sendMessage(Message msg):立即发送消息。

  • final boolean sendMessageDelayed(Message msg, long delayMillis):指定多少毫秒后发送消息。

  • Message:Handler接收和处理的消息对象。

    • 2个整型数值:轻量级存储int类型的数据。
    • 1个Object:任意对象。
    • replyTo:线程通信时使用。
    • what:用户自定义的消息码,让接收者识别消息。
  • MessageQueue:Message的队列。

    • 采用先进先出的方式管理Message。
    • 每一个线程最多可以拥有一个。
  • Looper:消息泵,是MessageQueue的管理者,会不断从MessageQueue中取出消息,并将消息分给对应的Handler处理。

    • 每个线程只有一个Looper。
    • Looper.prepare():为当前线程创建Looper对象。
    • Looper.myLooper():可以获得当前线程的Looper对象。
    • Handler:能把消息发送给MessageQueue,并负责处理Looper分给它的消息。

4:Handler如何去实现发送和处理消息

1: 使用Thread发送消息

Thread

2: 使用Runnable发送消息

Runnable.png

3: 使用Handler下载文件并更新进度条
1: 首先配置权限信息 读写权限问题

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.MOUNT_FORMAT_FILESYSTEMS" />

2: 在Android 6.0之后必须动态检测权限。所以在下载操作开始之前需要进行权限判断

Android6.0.png
发送消息,准备更新UI操作.png
handleMessage.png

权限问题处理方法

权限问题处理方法.png

4: 使用 handler实现倒计时功能
首先强调一下需要注意的问题吧
Handler在进行异步操作并处理返回结果时经常被使用。通常我们的代码会这样实现。

Handler

但是,其实上面的代码可能导致内存泄露,当你使用Android lint工具的话,会得到这样的警告:

warning.png

以下几种情况都可能存在内存泄漏的情况

1.当一个Android应用启动的时候,会自动创建一个供应用主线程使用的Looper实例。Looper的主要工作就是一个一个处理消息队列中的消息对象。在Android中,所有Android框架的事件(比如Activity的生命周期方法调用和按钮点击等)都是放入到消息中,然后加入到Looper要处理的消息队列中,由Looper负责一条一条地进行处理。主线程中的Looper生命周期和当前应用一样长。

2.当一个Handler在主线程进行了初始化之后,我们发送一个target为这个Handler的消息到Looper处理的消息队列时,实际上已经发送的消息已经包含了一个Handler实例的引用,只有这样Looper在处理到这条消息时才可以调用Handler#handleMessage(Message)完成消息的正确处理。

3.在Java中,非静态的内部类和匿名内部类都会隐式地持有其外部类的引用。静态的内部类不会持有外部类的引用。

解决方式

  • 要解决这种问题,思路就是不适用非静态内部类,继承Handler时,要么是放在单独的类文件中,要么就是使用静态内部类。因为静态的内部类不会持有外部类的引用,所以不会导致外部类实例的内存泄露。当你需要在静态内部类中调用外部的Activity时,我们可以使用弱引用来处理。另外关于同样也需要将Runnable设置为静态的成员属性。注意:一个静态的匿名内部类实例不会持有外部类的引用。
🤢.png

面试要点

  • 这里 我们可以逐步分析:
public Handler(Callback callback, boolean async) {
        
       //得到主线程(已经被ActivityThread初始化好)的looper
       mLooper = Looper.myLooper();
       if (mLooper == null) {
           throw new RuntimeException(
               "Can't create handler inside thread that has not called Looper.prepare()");
       }
       
       //得到主线程(已经被ActivityThread初始化好)的looper的MessageQueue,注释:①
       mQueue = mLooper.mQueue;
       mCallback = callback;
       mAsynchronous = async;
}

注意,看到了吗? 这里是核心:mLooper = Looper.myLooper();,

public static Looper myLooper() {
     return sThreadLocal.get();
}

而这个Looper对象,是在我们启动程序的时候,也就是ActivityThread 中的main方法帮我们初始化的,也就是我们主线程的Looper。

public static void prepareMainLooper() {
     ···
     prepare(false);
     ···
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
          throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

我们在子线程 使用 handler的实例进行 sendMessage(Message msg) 的时候:

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        //这里的代码和上面的注释①对应。
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }

最终走向enqueueMessage:

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

最终把我们的Message,放进了主线程的MessageQueue里面进行循环!

推荐阅读更多精彩内容