专栏首页编码前线Android消息机制——Handler

Android消息机制——Handler

概述

Handler是Android消息机制的上层接口。通过它可以轻松地将一个任务切换到Handler所在的线程中去执行。通常情况下,Handler的使用场景就是 更新UI

Handler的使用

在子线程中,进行耗时操作,执行完操作后,发送消息,通知主线程更新UI。

public class Activity extends android.app.Activity {    private Handler mHandler = new Handler(){        @Override        public void handleMessage(Message msg) {            super.handleMessage(msg);            // 更新UI        }    };    @Override    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {        super.onCreate(savedInstanceState, persistentState);        setContentView(R.layout.activity_main);        new Thread(new Runnable() {            @Override            public void run() {                // 执行耗时任务                ...                // 任务执行完后,通知Handler更新UI                Message message = Message.obtain();                message.what = 1;                mHandler.sendMessage(message);            }        }).start();    }}

Handler架构

Handler消息机制主要包括: MessageQueueHandlerLooper这三大部分,以及 MessageMessage:需要传递的消息,可以传递数据; MessageQueue:消息队列,但是它的内部实现并不是用的队列,而是通过单链表的数据结构来维护消息列表,因为单链表在插入和删除上比较有优势。主要功能是向消息池投递消息( MessageQueue.enqueueMessage)和取走消息池的消息( MessageQueue.next)。 Handler:消息辅助类,主要功能是向消息池发送各种消息事件( Handler.sendMessage)和处理相应消息事件( Handler.handleMessage); Looper:消息控制器,不断循环执行( Looper.loop),从MessageQueue中读取消息,按分发机制将消息分发给目标处理者。

从上面的类图可以看出:

  • Looper有一个MessageQueue消息队列;
  • MessageQueue有一组待处理的Message;
  • Message中记录发送和处理消息的Handler;
  • Handler中有Looper和MessageQueue。

MessageQueue、Handler和Looper三者之间的关系: 每个线程中只能存在一个Looper,Looper是保存在ThreadLocal中的。 主线程(UI线程)已经创建了一个Looper,所以在主线程中不需要再创建Looper,但是在其他线程中需要创建Looper。 每个线程中可以有多个Handler,即一个Looper可以处理来自多个Handler的消息。 Looper中维护一个MessageQueue,来维护消息队列,消息队列中的Message可以来自不同的Handler。

Handler的运行流程

在子线程执行完耗时操作,当Handler发送消息时,将会调用 MessageQueue.enqueueMessage,向消息队列中添加消息。 当通过 Looper.loop开启循环后,会不断地从消息池中读取消息,即调用 MessageQueue.next, 然后调用目标Handler(即发送该消息的Handler)的 dispatchMessage方法传递消息, 然后返回到Handler所在线程,目标Handler收到消息,调用 handleMessage方法,接收消息,处理消息。

源码分析

在子线程创建Handler

class LooperThread extends Thread {      public Handler mHandler;      public void run() {          Looper.prepare();          mHandler = new Handler() {              public void handleMessage(Message msg) {                  // process incoming messages here              }          };          Looper.loop();      }  }

从上面可以看出,在子线程中创建Handler之前,要调用 Looper.prepare()方法,Handler创建后,还要调用 Looper.loop()方法。而前面我们在主线程创建Handler却不要这两个步骤,因为系统帮我们做了。

主线程的Looper

在ActivityThread的main方法,会调用 Looper.prepareMainLooper()来初始化Looper,并调用 Looper.loop()方法来开启循环。

public final class ActivityThread extends ClientTransactionHandler {    // ...    public static void main(String[] args) {        // ...        Looper.prepareMainLooper();        // ...        Looper.loop();    }}

Looper

从上可知,要使用Handler,必须先创建一个Looper。

初始化Looper

public final class Looper {    public static void prepare() {        prepare(true);    }    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));    }    public static void prepareMainLooper() {        prepare(false);        synchronized (Looper.class) {            if (sMainLooper != null) {                throw new IllegalStateException("The main Looper has already been prepared.");            }            sMainLooper = myLooper();        }    }    private Looper(boolean quitAllowed) {        mQueue = new MessageQueue(quitAllowed);        mThread = Thread.currentThread();    }    // ...}

从上可以看出,不能重复创建Looper,每个线程只能创建一个。创建Looper,并保存在 ThreadLocal。其中ThreadLocal是线程本地存储区(Thread Local Storage,简称TLS),每个线程都有自己的私有的本地存储区域,不同线程之间彼此不能访问对方的TLS区域。

开启Looper

public final class Looper {    // ...    public static void loop() {        // 获取TLS存储的Looper对象        final Looper me = myLooper();        if (me == null) {            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        final MessageQueue queue = me.mQueue;        // 进入loop主循环方法        for (;;) {            Message msg = queue.next(); // 可能会阻塞,因为next()方法可能会无线循环            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            // This must be in a local variable, in case a UI event sets the logger            final Printer logging = me.mLogging;            if (logging != null) {                logging.println(">>>>> Dispatching to " + msg.target + " " +                        msg.callback + ": " + msg.what);            }            // ...            final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;            final long dispatchEnd;            try {                // 获取msg的目标Handler,然后分发Message                msg.target.dispatchMessage(msg);                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;            } finally {                if (traceTag != 0) {                    Trace.traceEnd(traceTag);                }            }            // ...            msg.recycleUnchecked();        }    }}

Handler

创建Handler

public class Handler {    // ...    public Handler() {        this(null, false);    }    public Handler(Callback callback, boolean async) {        // ...        // 必须先执行Looper.prepare(),才能获取Looper对象,否则为null        mLooper = Looper.myLooper();        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread " + Thread.currentThread()                        + " that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;  // 消息队列,来自Looper对象        mCallback = callback;     // 回调方法        mAsynchronous = async;    // 设置消息是否为异步处理方式    }}

发送消息

子线程通过Handler的post()方法或send()方法发送消息,最终都是调用 sendMessageAtTime()方法。

post方法:

public final boolean post(Runnable r){    return sendMessageDelayed(getPostMessage(r), 0);}public final boolean postAtTime(Runnable r, long uptimeMillis){    return sendMessageAtTime(getPostMessage(r), uptimeMillis);}public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);}public final boolean postDelayed(Runnable r, long delayMillis){    return sendMessageDelayed(getPostMessage(r), delayMillis);}private static Message getPostMessage(Runnable r) {    Message m = Message.obtain();    m.callback = r;    return m;}

send方法:

public final boolean sendMessage(Message msg){    return sendMessageDelayed(msg, 0);}public final boolean sendEmptyMessage(int what){    return sendEmptyMessageDelayed(what, 0);}public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {    Message msg = Message.obtain();    msg.what = what;    return sendMessageDelayed(msg, delayMillis);}public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {    Message msg = Message.obtain();    msg.what = what;    return sendMessageAtTime(msg, uptimeMillis);}public final boolean sendMessageDelayed(Message msg, long delayMillis){    if (delayMillis < 0) {        delayMillis = 0;    }    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);}

sendMessageAtTime()

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);}private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {    msg.target = this;    if (mAsynchronous) {        msg.setAsynchronous(true);    }    return queue.enqueueMessage(msg, uptimeMillis);}

分发消息

在loop()方法中,获取到下一条消息后,执行 msg.target.dispatchMessage(msg),来分发消息到目标Handler。

public class Handler {    // ...    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            // 当Message存在回调方法,调用该回调方法            handleCallback(msg);        } else {            if (mCallback != null) {                // 当Handler存在Callback成员变量时,回调其handleMessage()方法                if (mCallback.handleMessage(msg)) {                    return;                }            }            // Handler自身的回调方法            handleMessage(msg);        }    }    private static void handleCallback(Message message) {        message.callback.run();    }}

总结

参考链接

  1. [Handler]https://developer.android.com/reference/android/os/Handler
  2. [Communicate with the UI thread]https://developer.android.com/training/multiple-threads/communicate-ui
  3. [Android消息机制]https://lrh1993.gitbooks.io/androidinterviewguide/content/android/basis/message-mechanism.html
  4. [一文看穿 Handler]http://yifeiyuan.me/blog/f77487d3.html
  5. [Android应用程序消息处理机制(Looper、Handler)分析]https://blog.csdn.net/luoshengyang/article/details/6817933
  6. [Android消息机制1-Handler(Java层)]http://gityuan.com/2015/12/26/handler-message-framework/
  7. [进程和线程]https://developer.android.com/guide/components/processes-and-threads.html

本文分享自微信公众号 - 编码前线(gh_acef1225aadd)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-03-17

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java中的transient关键字

    用户1205080
  • Lombok介绍及使用方法

    Lombok 是一个 Java 库,它作为插件安装至编辑器中,其作用是通过简单注解来精简代码,以此达到消除冗长代码的目的。

    用户1205080
  • 关于三种工厂模式的总结

    工厂模式分为简单工厂模式,工厂方法模式和抽象工厂模式,它们都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,目的是降低系统中代...

    用户1205080
  • [Android] Handler消息传递机制

    其实这块知识我都看过,但是读完这段话有些地方还是让我回想了一小会儿。想完就觉着既然回想了一遍,不如整理一篇博客出来好了。

    wOw
  • Android中Looper的架构设计与赏析

    看完本篇文章,你将搞清楚以下所有的关于Handler相关的任何问题。如果你以后在面试中碰到Handler相关的问题,相信你会给面试官眼前一亮的感觉。

    吴延宝
  • Handler都没搞懂,拿什么去跳槽啊?!

    做 Android 开发肯定离不开跟 Handler 打交道,它通常被我们用来做主线程与子线程之间的通信工具,而 Handler 作为 Android 中消息机...

    程序亦非猿
  • 每个 Android 开发者必须知道的消息机制问题总结

    不能,一个线程对应一个Looper对象,通过ThreadLocal保证一个线程只有一个Looper与之对应,如果多次调用Looper.prepare();则会抛...

    哲洛不闹
  • 异步线程大师Handler(源码+图+demo+常见问题)

    Handler 机制 源码+图+常见问题+Demo 详细记录(本文内容略长,但内容较为详细,推荐Android开发者可深入观看.如有问题,欢迎指正)

    Anymarvel
  • java用class.getClassLoader().getResourceAsStream方式读取properties文件路径问题

    class.getClassLoader().getResourceAsStream当中properties配置文件放到转移至 src目录下

    阮键
  • 挖洞经验 | Google Play Core Library中的代码执行漏洞

    年初2月,Oversecured公司就利用该系统探测发现了谷歌Google Play Core Library核心库中的一个高危代码执行漏洞,漏洞影响所有依赖调...

    FB客服

扫码关注云+社区

领取腾讯云代金券