android handler的机制和原理_Android消息机制——Handler

最新推荐文章于 2024-06-24 09:53:21 发布
最新推荐文章于 2024-06-24 09:53:21 发布
阅读量158 收藏
点赞数
文章标签： 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消息机制主要包括： MessageQueue、 Handler、 Looper这三大部分，以及 Message。 Message：需要传递的消息，可以传递数据； MessageQueue：消息队列，但是它的内部实现并不是用的队列，而是通过单链表的数据结构来维护消息列表，因为单链表在插入和删除上比较有优势。主要功能是向消息池投递消息（ MessageQueue.enqueueMessage）和取走消息池的消息（ MessageQueue.next）。 Handler：消息辅助类，主要功能是向消息池发送各种消息事件（ Handler.sendMessage）和处理相应消息事件（ Handler.handleMessage）； Looper：消息控制器，不断循环执行（ Looper.loop），从MessageQueue中读取消息，按分发机制将消息分发给目标处理者。

v2-8ece15cd204c70a8ce5a7c210dcdce06_b.jpg

从上面的类图可以看出：

  • 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。

v2-b8a4f61768ff40305f6f631bdee7b0db_b.png

Handler的运行流程

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

v2-419ace2f6bbde74d5d56f368289cc06a_b.jpg

源码分析

在子线程创建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();
    }
}

总结

v2-0a866d7ce5ac8ec6453d86aeaf486060_b.jpg

参考链接

  1. Handler
  2. Communicate with the UI thread
  3. Android消息机制
  4. 一文看穿 Handler
  5. Android应用程序消息处理机制（Looper、Handler）分析
  6. Android消息机制1-Handler(Java层)
  7. 进程和线程
weixin_39826080
关注
Android的Handler机制实现原理分析
02-26
先上图，让大家好理解下handler机制：handler机制示例图上面一共出现了几种类，ActivityThread，Handler，MessageQueue，Looper，msg（Message）,对这些类作简要介绍：ActivityThread：程序的启动入口，为什么要介绍这个类，是因为该类就是我们说的主线程，它对Looper进行操作的。Handler：字面意思是操控者，该类有比较重要的地方，就是通过handler来发送消息（sendMessage）到MessageQueue和操作控件的更新（handleMessage）。handler下面持有这MessageQueue和Looper的对象
[Android进阶】Handler机制原理解析
Web_boom的博客
02-23 8217
Handler是Android中提供的一种异步回调机制，也可以理解为线程间的消息机制。为了避免ANR,我们通常会把一些耗时操作（比如：网络请求、I/O操作、复杂计算等）放到子线程中去执行，而当子线程需要修改UI时则子线程需要通知主线程去完成修改UI的操作，则此时就需要我们使用Handler机制来完成子线程与主线程之间的通信。 Handler的一般使用步骤 在明确了Android中只有主线程能修改UI界面、子线程执行耗时操作的前提后，下面一起来学习下Handler的使用步骤。 在主线程中创建Handler
Android 13 Handler详解
最新发布
u010345983的博客
06-24 3472
Handler 是一套 Android 消息传递机制。在多线程应用场景中，将子线程中需要更新 UI 的操作消息，传递到 UI 主线程，从而实现子线程通知 UI 更新最终实现异步消息处理。说白了是用于线程之间的通信。Handler主要有4个重要类：Handler、Message、MessageQueue、Looper。Handler：负责消息的发送和处理，子线程中使用 sendMessage() 发送消息；在handleMessage()中处理。Message：消息载体，里面存储这线程消息。
Android——Handler详解
Yawn
05-27 6万+
1. 简介 Handler是一套 Android 消息传递机制 可以说只要有异步线程与主线程通信的地方就一定会有 Handler。 在多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理 使用Handler消息传递机制主要是为了多个线程并发更新UI的同时，保证线程安全 2. 相关概念解释 Handler、Message、Message Queue、Looper Android消息机制： 以Handler的sendMes
Android Handler消息机制原理最全解读（持续补充中）
热门推荐
Lance_W
05-13 7万+
Handler  在Android开发的过程中，我们常常会将耗时的一些操作放在子线程（work thread）中去执行，然后将执行的结果告诉 UI线程（main thread），熟悉Android的朋友都知道，UI的更新只能通过Main thread来进行。那么这里就涉及到了如何将 子线程的数据传递给main thread呢？  Android已经为我们提供了一个消息传递的机制——Hand...
Android基础知识（九）：Handler机制的原理分析
weixin_38196407的博客
02-22 1572
Handler机制的实现与原理分析 一、Handler机制简介 Handler机制是一套Android消息传递机制/异步通信机制。 Handler机制的作用在于：在多线程的应用场景下，将工作线程中需更新UI的操作信息传递到UI主线程，从而实现工作线程对UI的更新处理，最终实现异步消息的处理。此外，在多个线程并发更新UI的同时保证线程安全，从而避免线程操作不安全的问题。 二、Handler机制实现...
深入理解Android消息处理系统——Looper、Handler、Thread
03-23
而Android应用程序也是消息驱动的，按道理来说也应该提供消息循环机制。实际上谷歌参考了Windows的消息循环机制，也在Android系统中实现了消息循环机制。Android通过Looper 　熟悉Windows编程的朋友可能知道Windows...
安卓Android源码——HandlerMessage3.rar
10-11
在安卓（Android）开发中，`Handler`、`Message` 和 `Looper` 是实现线程间通信的关键组件，尤其在...通过深入研究这个"安卓Android源码——HandlerMessage3.rar"，你可以更好地理解这些机制，并在你的应用中灵活运用。
安卓Android源码——HandlerLooper2.rar
10-11
这个压缩包“安卓Android源码——HandlerLooper2.rar”可能会包含对这些概念的实例解析，比如如何自定义`Handler`，如何在子线程中使用`Looper`，以及如何调试和优化消息传递等。通过学习这些源码，开发者可以更深入...
安卓Android源码——HandlerMessage2.rar
10-11
本资源"安卓Android源码——HandlerMessage2.rar"可能包含了关于`Handler`和`Message`的深入实践和示例代码，下面我们将详细探讨这些核心组件。 `Handler` 是 Android 中用于在线程间传递消息的对象。它通常用于将...
安卓Android源码——HandlerLooper1.rar
10-11
在Android系统中，`Handler`、`Looper`和`MessageQueue`是三个核心组件，它们共同构成了Android消息处理机制，使得应用程序能够实现线程间的通信和异步任务执行。这个`HandlerLooper1.rar`文件可能包含了对这些概念...
Android的Handler机制原理详解
大模型训练
10-30 2250
在实际开发中，三种方法的使用都可行，具体用哪种方法，需结合你的实际情况及个人喜好。另外，在实际使用中往往将 Handler 写成静态内部类，这时需要注意防止内存泄露！（The handler class should be static or leaks might occur），具体代码见上方！如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。
android handler机制的原理,Android Handler 消息机制+工作原理
weixin_35006433的博客
05-30 184
我们先来说下大多数都会这样回答，一个Handler允许发送和处理Message和Runable对象，UI主线程会自动分配一个Looper(消息轮询器)，每个Looper中封装着MessageQueue(消息队列)，遵循先进先出原则。Looper负责不断的从自己的消息队列里取出队头的任务或消息执行。一般是在子线程执行完耗时操作之后，通过Handler的sendMessage或post方法将Messa...
Android 消息机制
qq_15796477的博客
05-03 260
转载地址：https://blog.csdn.net/qian520ao/article/details/78262289?locationNum=2&amp;fps=1前言QuestionsLooper 死循环为什么不会导致应用卡死主线程的消息循环机制是什么ActivityThread 的动力是什么Handler 是如何能够线程切换子线程有哪些更新UI的方法runOnUiThread创建Hand...
Android系统Handler详解
allen_xu_2012_new的博客
06-11 3073
Handler是一套 Android 消息传递机制,主要用于线程间通信。用最简单的话描述： handler其实就是主线程在起了一个子线程，子线程运行并生成Message，Looper获取message并传递给Handler，Handler逐个获取子线程中的Message.Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线程间通信可以说只要有异步线程与主线程通信的地方就一定会有 Handler。
android Handler机制原理解析（一篇就够，包你形象而深刻）
luoyingxing的博客
01-16 3万+
首先，我将Handler相关的原理机制形象的描述为以下情景： Handler：快递员 Message：包裹 MessageQueue：快递仓储空间 Looper：配送车 某天，你想给朋友寄一件礼物，首先你会包裹好，下单加了某家的快递员上门取件，快递员揽收了你的包裹后，会将包裹送往站点的仓储空间，等待配送车送出你的包裹。等配送车来了，就按照你的包裹信息，送到指定地方站点，然后会有相应的快递员将你的包...
扒一扒面试必问的Handler
鸿蒙开发知识记录
06-22 462
前言 Handler作为Android代码编写以及面试时经常遇到的内容，有必要花个时间整理一下，毕竟写过的东西印象会更加深刻。 1.什么是Handler? 1.1 定义 源码里面捞出来的内容，英文不难看懂。主要就是说每个Handler会和每个线程以及线程对应的消息队列相绑定。之后消息就可通过Handler在线程之间传递。 A Handler allows you to send and process {@link Message} and Runnable objects associated
Android消息机制Handler原理分析
qq_25367755的博客
10-15 1446
1.Message的回调方法：message.callback.run()，优先级最高2.Handler的回调方法 Handler.mCallBack.handleMessage(msg)3.Handler的默认方法：Handler.handleMessage(msg)上图是Android消息机制的图解图中分为四个部分，Handler, Looper, MessageQueue, MessageHander主要是将消息发送到MessageQueue中，和处理接收到消息后执行的代码。
android handler的机制和原理_Android-Handler消息机制
weixin_39781783的博客
11-23 408
一.前言前不久写过一篇 Android----Handler消息机制，那篇文章只是对 Android 中的 Hanlder 机制的简单介绍，最近又重新回顾一下，发现了之前许多没有注意到的细节，因此就增加一篇 进阶篇。Android----Handler消息机制二.简介Android 中的消息机制主要是指 Handler 的运行机制和在 MessageQueue 和 Looper 的配合下 将一个线...
Handler机制详解：Java与Native层的消息传递与 epoll 探究
Handler机制及原理探究深入探讨了Android系统中的一个重要组件——Handler，它在Java和Native层之间扮演着关键角色，实现了线程间的消息传递以及跨进程通信。Handler的使用以其简单性和强大的功能著称，尤其在多线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值