Android异步通信：手把手教你使用Handler消息传递机制(含实例讲解）

最新推荐文章于 2025-06-05 11:56:25 发布
原创 最新推荐文章于 2025-06-05 11:56:25 发布 · 3.8w 阅读 · 182 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Android #异步通信 #Handler #消息传递 #多线程

前言

  • 在Android开发的多线程应用场景中，Handler机制十分常用
  • 今天，我将献上一份 Handler机制的使用教程 ，希望你们会喜欢

Anroid Handler系列文章教程
Android异步通信：Handler机制学习攻略
Android异步通信：Handler使用教程
Android异步通信：Handler工作原理
Android异步通信：Handler机制源码
Android异步通信：详解Handler内存泄露的原因

目录

示意图

1. Handler 机制简介

  • 定义
    一套 Android 消息传递机制 / 异步通信机制

  • 作用

在多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理
示意图

  • 为什么要用 Handler消息传递机制
    答：多个线程并发更新UI的同时 保证线程安全。具体描述如下

示意图

  • 总结
    使用Handler的原因：将工作线程需操作UI的消息 传递 到主线程，使得主线程可根据工作线程的需求 更新UI，从而避免线程操作不安全的问题

2. 相关概念

关于 Handler 机制中的相关概念如下：

在下面的讲解中，我将直接使用英文名讲解，即 Handler、Message、Message Queue、Looper，希望大家先熟悉相关概念

示意图

3. 使用方式

  • Handler使用方式 因发送消息到消息队列的方式不同而不同
  • 共分为2种：使用Handler.sendMessage（）、使用Handler.post（）

4. 使用步骤

方式1：使用 Handler.sendMessage（）

在该使用方式中，又分为2种：新建Handler子类（内部类）、匿名 Handler子类

但本质相同，即 继承了Handler类 & 创建了子类

/** 
  * 方式1：新建Handler子类（内部类）
  */

    // 步骤1：自定义Handler子类（继承Handler类） & 复写handleMessage（）方法
    class mHandler extends Handler {

        // 通过复写handlerMessage() 从而确定更新UI的操作
        @Override
        public void handleMessage(Message msg) {
         ...// 需执行的UI操作
            
        }
    }

    // 步骤2：在主线程中创建Handler实例
        private Handler mhandler = new mHandler();

    // 步骤3：创建所需的消息对象
        Message msg = Message.obtain(); // 实例化消息对象
        msg.what = 1; // 消息标识
        msg.obj = "AA"; // 消息内容存放

    // 步骤4：在工作线程中 通过Handler发送消息到消息队列中
    // 可通过sendMessage（） / post（）
    // 多线程可采用AsyncTask、继承Thread类、实现Runnable
        mHandler.sendMessage(msg);

    // 步骤5：开启工作线程（同时启动了Handler）
    // 多线程可采用AsyncTask、继承Thread类、实现Runnable


/** 
  * 方式2：匿名内部类
  */
   // 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
            private Handler mhandler = new  Handler(){
                // 通过复写handlerMessage()从而确定更新UI的操作
                @Override
                public void handleMessage(Message msg) {
                        ...// 需执行的UI操作
                    }
            };

  // 步骤2：创建消息对象
    Message msg = Message.obtain(); // 实例化消息对象
  msg.what = 1; // 消息标识
  msg.obj = "AA"; // 消息内容存放
  
  // 步骤3：在工作线程中 通过Handler发送消息到消息队列中
  // 多线程可采用AsyncTask、继承Thread类、实现Runnable
   mHandler.sendMessage(msg);

  // 步骤4：开启工作线程（同时启动了Handler）
  // 多线程可采用AsyncTask、继承Thread类、实现Runnable

方式2：使用Handler.post（）

// 步骤1：在主线程中创建Handler实例
    private Handler mhandler = new mHandler();

    // 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
    // 需传入1个Runnable对象
    mHandler.post(new Runnable() {
            @Override
            public void run() {
                ... // 需执行的UI操作 
            }

    });

    // 步骤3：开启工作线程（同时启动了Handler）
    // 多线程可采用AsyncTask、继承Thread类、实现Runnable

5. 实例讲解

本文将用实例逐个讲解 Handler的用法

注：

  1. 由于Handler的作用 = 将工作线程需操作UI的消息 传递 到主线程，使得主线程可根据工作线程的需求 更新UI，从而避免线程操作不安全的问题
  2. 故下文的实例 = 1个简单 “更新UI操作” 的案例
  3. 主布局文件相同 = 1个用于展示的TextView，具体如下：

布局代码：activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    tools:context="com.example.carson_ho.handler_learning.MainActivity">

    <TextView
        android:id="@+id/show"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" />
</RelativeLayout>

实例的源码地址：Carson_Ho的Github：Handler
（建议：先fork下来再看，效果会更好哦！）

5.1 使用 Handler.sendMessage（）

方式1：新建Handler子类（内部类）
  • 具体使用
public class MainActivity extends AppCompatActivity {
    
    public TextView mTextView;
    public Handler mHandler;

    // 步骤1：（自定义）新创建Handler子类(继承Handler类) & 复写handleMessage（）方法
    class Mhandler extends Handler {

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

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

        mTextView = (TextView) findViewById(R.id.show);

        // 步骤2：在主线程中创建Handler实例
        mHandler = new Mhandler();
       
        // 采用继承Thread类实现多线程演示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                 // 步骤3：创建所需的消息对象
                 Message msg = Message.obtain();
                 msg.what = 1; // 消息标识
                 msg.obj = "A"; // 消息内存存放

                 // 步骤4：在工作线程中 通过Handler发送消息到消息队列中
                 mHandler.sendMessage(msg);
            }
        }.start();
        // 步骤5：开启工作线程（同时启动了Handler）

        // 此处用2个工作线程展示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 通过sendMessage（）发送
                 // a. 定义要发送的消息
                 Message msg = Message.obtain();
                 msg.what = 2; //消息的标识
                 msg.obj = "B"; // 消息的存放
                 // b. 通过Handler发送消息到其绑定的消息队列
                 mHandler.sendMessage(msg);
            }
        }.start();

    }
}
  • 运行结果

示意图

方式2：匿名内部类
  • 具体使用
public class MainActivity extends AppCompatActivity {
    
    public TextView mTextView;
    public Handler mHandler;

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

        mTextView = (TextView) findViewById(R.id.show);

        // 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
        mHandler = new Handler(){
            // 通过复写handlerMessage()从而确定更新UI的操作
            @Override
            public void handleMessage(Message msg) {
                // 根据不同线程发送过来的消息，执行不同的UI操作
                switch (msg.what) {
                    case 1:
                        mTextView.setText("执行了线程1的UI操作");
                        break;
                    case 2:
                        mTextView.setText("执行了线程2的UI操作");
                        break;
                }
            }
        };
        // 采用继承Thread类实现多线程演示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                 // 步骤3：创建所需的消息对象
                 Message msg = Message.obtain();
                 msg.what = 1; // 消息标识
                 msg.obj = "A"; // 消息内存存放

                 // 步骤4：在工作线程中 通过Handler发送消息到消息队列中
                 mHandler.sendMessage(msg);
            }
        }.start();
        // 步骤5：开启工作线程（同时启动了Handler）

        // 此处用2个工作线程展示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 通过sendMessage（）发送
                 // a. 定义要发送的消息
                 Message msg = Message.obtain();
                 msg.what = 2; //消息的标识
                 msg.obj = "B"; // 消息的存放
                 // b. 通过Handler发送消息到其绑定的消息队列
                 mHandler.sendMessage(msg);
            }
        }.start();

    }

}
  • 运行结果

示意图

5.2 使用 Handler.post（）

  • 具体使用
public class MainActivity extends AppCompatActivity {
    
    public TextView mTextView;
    public Handler mHandler;

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

        mTextView = (TextView) findViewById(R.id.show);

        // 步骤1：在主线程中创建Handler实例
        mHandler = new Handler();

        // 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 通过psot（）发送，需传入1个Runnable对象
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 指定操作UI内容
                        mTextView.setText("执行了线程1的UI操作");
                    }

                });
            }
        }.start();
        // 步骤3：开启工作线程（同时启动了Handler）

        // 此处用2个工作线程展示
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        mTextView.setText("执行了线程2的UI操作");
                    }

                });
            }
        }.start();

    }

}
  • 运行结果
    示意图

至此，关于Handler的异步消息传递机制的使用讲解完毕。

6. 总结

欢迎关注Carson_Ho的优快云博客 与 公众号！

博客链接：https://carsonho.blog.youkuaiyun.com/

请点赞！因为你的鼓励是我写作的最大动力！

Python 网络编程实战：手把手教你打造高效 HTTP 服务器！
威哥说编程
02-09 1477
通过本篇文章，你学习了如何使用 Python 实现一个高效的 HTTP 服务器。首先，我们用模块创建了一个简单的 HTTP 服务器，然后通过socket和threading模块构建了支持并发请求的 HTTP 服务器。最后，我们使用优化了服务器的性能，减少了线程创建的开销。掌握 Python 网络编程，不仅能够帮助你理解 HTTP 协议，还能让你为实际的网络应用程序提供强大的后端支持。如果你想进一步提升服务器的性能，可以尝试使用异步框架（如asyncio）或更复杂的 Web 框架（如FlaskDjango。
Android中Handler消息传递机制
01-04
Handler 是用来干什么的？ 1）执行计划任务，可以在预定的时间执行某些任务，可以模拟定时器 2）线程间通信。在Android的应用启动时，会创建一个主线程，主线程会创建一个消息队列来处理各种消息。当你创建子线程时，你可以在你的子线程中拿到父线程中创建的Handler 对象，就可以通过该对象向父线程的消息队列发送消息了。由于Android要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。 出于性能优化考虑，Android的UI操作并不是线程安全的，这意味着如果有多个线程并发操作UI组件，可能导致线程安全问题。为了解决这个问题，Android制定了一条简单的规则：只允许U
Handler消息传递机制
weixin_30920597的博客
09-18 89
使用方法 1.若在UI主线程中，则系统已经初始化了一个Looper对象（因为主线程也是一个消息循环，因此具有一个looper，主线程的所有工作都是由其looper完成的looper不断从消息队列中抓取消息，然后完成消息指定的任务），否则要自己创建一个looper对象并启动。我们无法通过构造器创建looper，而要调用looper的 prepare()方法，此方法保证每个线程都只有一个...
【Android基础回顾】二：handler消息机制
最新发布
Shujie
06-05 1140
Android 的 Handler 机制 是 Android 应用中实现线程间通信、任务调度、消息分发的核心机制之一，它基于 消息队列（MessageQueue）+ 消息循环（Looper）+ 消息处理器（Handler） 组成。
Android Handler
weixin_34329187的博客
01-26 140
快一年没更新博客了， 这一年有些疲于奔命， 详细的在Q空间里再写吧. 因为转型做Android了， 开始新的学习历程了， 望此次重拾博客有新成长新感悟... 此文是关于Handler的。 Handler主要接受子线程发送的数据， 并用此数据配合主线程更新UI。 当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) ...
Go net_http包使用宝典：手把手教你构建快速响应的HTTP服务
[Go net_http包使用宝典：手把手教你构建快速响应的HTTP服务](https://organicprogrammer.com/images/golang-http1-1-client-flow.png) # 1. Go net_http包基础介绍 Go语言的标准库中的`net/http`包，为开发者提供...
Netty入门：手把手教你写小例子
Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。以下知识点涵盖了Netty的基础概念、工作原理、核心组件以及入门级示例的解释。 ### Netty基础概念 - **网络...
STM32单片机编程宝典：手把手教你提高SPI接口性能
[STM32单片机编程宝典：手把手教你提高SPI接口性能](https://img-blog.csdnimg.cn/direct/10c17a74ab934a1fa68313a74fae4107.png) # 1. STM32单片机SPI接口概述 ## 1.1 SPI接口简介 SPI（Serial Peripheral ...
【Python Widgets入门指南】：手把手教你快速掌握界面元素的创建与应用
# 1. Python Widgets简介 ## 1.1 什么是Widgets 在Python的Tkinter库中，Widgets（小部件）是构成图形用户界面（GUI）的基本元素。它们可以是按钮、文本框、滑块等，为用户提供与应用程序交互的界面。...
Handler 消息传递机制
zengchao2013的专栏
07-18 481
众所周知，Android的UI操作并不是线程安全的，这就意味着如果有多个线程并发操作UI组件，可能导致线程安全问题，为了解决这个问题，Android制定了一条简单的规则：只允许UI线程修改Activity里的UI组件。   Handler类的主要作用有两个： 一是在新启动的线程中发送消息 二是在主线程中获取，处理消息。 关键的问题是，怎么让主线程适时地处理新启动的线程发送的消息，显然只能通
Handler消息传递机制（一）
tuke_tuke的博客
03-02 2203
为什么要用Handler： 出于性能优化考虑，Android的UI操作并不是线程安全的，这意味着如果有多个线程并发操作UI组件，可能导致线程安全问题。为了解决这个问题，Android制定了一条简单的原则：只允许UI线程（亦即主线程）修改Activity中的UI组件。 当一个程序第一次启动时，Android会同时启动一条主线程，主线程主要负责处理与UI相关的事件，如用户的按键事件、用户接触屏幕的
handler
03-14
<think>嗯，用户想了解“handler”在编程或软件开发中的概念和用法。首先，我需要回忆一下自己对这个术语的理解。Handler这个词在计算机科学中确实很常见，但具体含义可能因上下文而异。比如，在事件驱动编程、网络通信、操作系统等不同领域，Handler可能有不同的应用场景。 首先，我应该从基础的定义入手。Handler通常翻译为“处理器”或“处理程序”，主要用于处理特定的事件、请求或数据。例如，在用户界面开发中，点击按钮会触发一个事件，这时候就需要一个事件处理函数（event handler）来响应这个动作。这种情况下，Handler的作用是定义当某个事件发生时应执行的代码逻辑。 接下来，可能需要分不同场景来详细说明Handler的用法。例如，在事件驱动编程中，Handler通常与事件监听器（event listener）配合使用，当特定事件被触发时，对应的Handler就会被调用。比如在JavaScript中，可以为按钮添加一个点击事件的Handler，当用户点击按钮时执行相应的函数。 然后，网络编程中的Handler也是一个重要应用。比如，在服务器处理客户端请求时，每个请求可能需要不同的处理逻辑，这时候可以通过不同的Handler来分发和处理请求。例如，使用Python的Flask框架时，可以通过装饰器定义不同URL路径对应的Handler函数，处理不同的HTTP请求。 另外，操作系统中的信号处理（signal handling）也是一个例子。当进程接收到操作系统发送的信号（如SIGINT中断信号）时，可以通过注册一个信号Handler来定义如何处理该信号，比如优雅地关闭程序或执行清理操作。 还需要考虑异步编程中的Handler，比如在Node.js中，回调函数（callback）就是一种Handler，用于处理异步操作完成后的结果。或者在使用消息队列时，消费者可能需要一个消息处理Handler来处理接收到的消息。 不过，用户可能已经对这些基本概念有所了解，所以需要进一步深入，或者提供一些具体实例。比如，可以结合代码示例，展示不同语言或框架中Handler的具体实现方式。例如，在JavaScript中的事件处理，或者Go语言中的HTTP请求处理。 同时，要注意到用户提供的引用内容。例如，引用[1]提到Go语言中使用goroutine来并发执行函数，这可能与异步处理或并发处理中的Handler有关。引用[2]讨论了I/O阻塞对CPU利用率的影响，或许在讨论网络请求处理时，如何高效使用Handler来避免阻塞。引用[3]关于消息代理的分发机制，可能与消息处理Handler相关。引用[4]似乎与许可证无关，暂时可以忽略。 因此，在回答时，可能需要结合这些引用中的相关内容，比如在Go语言中使用goroutine来处理并发请求，避免阻塞，提高CPU利用率。例如，在HTTP服务器中，每个请求可以启动一个goroutine来处理，这样主线程不会被阻塞，能够处理更多请求，提升性能。这种情况下，每个请求的处理逻辑可以视为一个Handler函数，由goroutine异步执行。 另外，消息代理中的Handler可能负责接收消息并分发给订阅者，确保消息的正确处理，如引用[3]所述。这种情况下，Handler需要处理消息的路由、确认、错误处理等，保证消息的至少一次或恰好一次传递。 总结来说，Handler的用途广泛，但核心都是处理特定的事件或请求。需要分场景说明，并结合代码示例和用户提供的引用内容，展示其在不同上下文中的具体应用和最佳实践。此外，生成的相关问题需要围绕Handler的不同应用场景、设计模式、性能优化等方面展开，帮助用户进一步探索。</think>### Handler 的概念与用法解析 在编程和软件开发中，**Handler（处理器）** 是一种用于**响应特定事件或管理特定任务**的代码模块。其核心作用是将程序逻辑与事件/请求的触发机制解耦，实现模块化和可维护性。以下是不同场景下的具体应用： --- #### 1. **事件驱动编程** 在图形界面（GUI）或前端开发中，Handler 用于处理用户交互事件（如点击、键盘输入）。 **示例**：JavaScript 中的点击事件处理器： ```javascript document.getElementById("myButton").addEventListener("click", function() { alert("按钮被点击！"); }); ``` - **功能**：当按钮被点击时，触发匿名函数执行弹窗操作[^1]。 --- #### 2. **网络请求处理** 在后端开发中，Handler 用于处理 HTTP 请求，并根据路由分发逻辑。 **示例**：Go 语言的 HTTP 处理器（结合 Goroutine 避免阻塞[^2]）： ```go func main() { http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) { go processRequest() // 使用 Goroutine 异步处理请求 fmt.Fprintf(w, "请求已接收") }) http.ListenAndServe(":8080", nil) } ``` - **功能**：当访问 `/hello` 路径时，异步处理请求并立即响应客户端。 --- #### 3. **消息队列与异步通信** 在分布式系统中，Handler 用于消费消息队列中的事件（如 RabbitMQ 或 Kafka）。 **示例**：消息代理中的订阅处理器[^3]： ```python def message_handler(channel, method, properties, body): print(f"收到消息：{body}") channel.basic_ack(delivery_tag=method.delivery_tag) channel.basic_consume(queue="my_queue", on_message_callback=message_handler) ``` - **功能**：从队列中读取消息并确保至少一次交付。 --- #### 4. **操作系统信号处理** 在系统编程中，Handler 用于捕获和处理操作系统信号（如 `SIGINT`）。 **示例**：Python 中的信号处理器： ```python import signal import sys def signal_handler(sig, frame): print("接收到终止信号，优雅退出...") sys.exit(0) signal.signal(signal.SIGINT, signal_handler) ``` - **功能**：用户按下 `Ctrl+C` 时，执行清理逻辑后退出。 --- #### 5. **设计模式中的应用** Handler 也常用于责任链模式（Chain of Responsibility），将多个处理器串联以依次处理请求。 **示例**：日志处理链： ```java public abstract class Logger { protected Logger next; public void setNext(Logger next) { this.next = next; } public abstract void handle(String message); } public class ErrorLogger extends Logger { public void handle(String message) { if (message.contains("ERROR")) { System.out.println("错误日志：" + message); } else if (next != null) { next.handle(message); } } } ``` - **功能**：根据消息类型选择处理器，未处理则传递给下一环节。 --- ### 性能优化与注意事项 - **异步处理**：避免阻塞主线程，如 Go 的 Goroutine 或 Node.js 的异步回调。 - **错误处理**：在 Handler 中需捕获异常，防止进程崩溃（如网络请求超时）。 - **资源管理**：及时释放文件句柄、数据库连接等资源，避免内存泄漏。 ---
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值