鸿蒙OS 线程间通信

🕗 发布于 2024-09-21 23:54 harmonyos android 华为笔记 开发语言

鸿蒙OS 线程间通信概述

在开发过程中，开发者经常需要在当前线程中处理下载任务等较为耗时的操作，但是又不希望当前的线程受到阻塞。此时，就可以使用 EventHandler 机制。EventHandler 是 HarmonyOS 用于处理线程间通信的一种机制，可以通过 [EventRunner] 创建新线程，将耗时的操作放到新线程上执行。这样既不阻塞原来的线程，任务又可以得到合理的处理。比如：主线程使用 EventHandler 创建子线程，子线程做耗时的下载图片操作，下载完成后，子线程通过 EventHandler 通知主线程，主线程再更新 UI。

基本概念
EventRunner 是一种事件循环器，循环处理从该 EventRunner 创建的新线程的事件队列中获取 InnerEvent 事件或者 Runnable 任务。InnerEvent 是 EventHandler 投递的事件。

EventHandler 是一种用户在当前线程上投递 InnerEvent 事件或者 Runnable 任务到异步线程上处理的机制。每一个 EventHandler 和指定的 EventRunner 所创建的新线程绑定，并且该新线程内部有一个事件队列。EventHandler 可以投递指定的 InnerEvent 事件或 Runnable 任务到这个事件队列。EventRunner 从事件队列里循环地取出事件，如果取出的事件是 InnerEvent 事件，将在 EventRunner 所在线程执行 processEvent 回调；如果取出的事件是 Runnable 任务，将在 EventRunner 所在线程执行 Runnable 的 run 回调。一般，EventHandler 有两个主要作用：

在不同线程间分发和处理 InnerEvent 事件或 Runnable 任务。
延迟处理 InnerEvent 事件或 Runnable 任务。

运作机制
EventHandler 的运作机制如下图所示：

在这里插入图片描述

使用 EventHandler 实现线程间通信的主要流程：

EventHandler 投递具体的 InnerEvent 事件或者 Runnable 任务到 EventRunner 所创建的线程的事件队列。
EventRunner 循环从事件队列中获取 InnerEvent 事件或者 Runnable 任务。
处理事件或任务：

如果 EventRunner 取出的事件为 InnerEvent 事件，则触发 EventHandler 的回调方法并触发 EventHandler 的处理方法，在新线程上处理该事件。
如果 EventRunner 取出的事件为 Runnable 任务，则 EventRunner 直接在新线程上处理 Runnable 任务。

约束限制
在进行线程间通信的时候，EventHandler 只能和 EventRunner 所创建的线程进行绑定，EventRunner 创建时需要判断是否创建成功，只有确保获取的 EventRunner 实例非空时，才可以使用 EventHandler 绑定 EventRunner。
一个 EventHandler 只能同时与一个 EventRunner 绑定，一个 EventRunner 上可以创建多个 EventHandler。

鸿蒙OS 线程间通信开发指导

EventHandler开发场景

EventHandler 的主要功能是将 InnerEvent 事件或者 Runnable 任务投递到其他的线程进行处理，其使用的场景包括：

开发者需要将 InnerEvent 事件投递到新的线程，按照优先级和延时进行处理。投递时，EventHandler 的优先级可在 IMMEDIATE、HIGH、LOW、IDLE 中选择，并设置合适的 delayTime。
开发者需要将 Runnable 任务投递到新的线程，并按照优先级和延时进行处理。投递时， EventHandler 的优先级可在 IMMEDIATE、HIGH、LOW、IDLE 中选择，并设置合适的 delayTime。
开发者需要在新创建的线程里投递事件到原线程进行处理。

EventRunner工作模式

EventRunner 的工作模式可以分为托管模式和手动模式。两种模式是在调用 EventRunner 的 create() 方法时，通过选择不同的参数来实现的，详见 API 参考。默认为托管模式。

托管模式：不需要开发者调用 run() 和 stop() 方法去启动和停止 EventRunner。当 EventRunner 实例化时，系统调用 run() 来启动 EventRunner；当 EventRunner 不被引用时，系统调用 stop() 来停止 EventRunner。
手动模式：需要开发者自行调用 EventRunner 的 run() 方法和 stop() 方法来确保线程的启动和停止。

接口说明

EventHandler

EventHandler 的属性 Priority (优先级)介绍：
EventRunner 将根据优先级的高低从事件队列中获取事件或者 Runnable 任务进行处理。

在这里插入图片描述

EventHandler 的主要接口介绍：
在这里插入图片描述

EventRunner

EventRunner的主要接口介绍：
在这里插入图片描述

InnerEvent

InnerEvent的属性介绍：
在这里插入图片描述

InnerEvent的主要接口介绍：
在这里插入图片描述

开发步骤
EventHandler 投递 InnerEvent 事件

EventHandler 投递 InnerEvent 事件，并按照优先级和延时进行处理，开发步骤如下：

创建 EventHandler 的子类，在子类中重写实现方法

processEvent() 来处理事件。
   private class MyEventHandler extends EventHandler {
       private MyEventHandler(EventRunner runner) {
       super(runner);
       }
       // 重写实现processEvent方法
       @Override
       public void processEvent(InnerEvent event) {
       super.processEvent(event);
       if (event == null) {
               return;
       }
       int eventId = event.eventId;
       long param = event.param;
       switch (eventId | param) {
               case CASE1:
                   // 待执行的操作，由开发者定义
               break;
           default:
           break;
       }
       }
   }

创建 EventRunner，以手动模式为例。

  EventRunner runner = EventRunner.create(false);// create()的参数是 true时，则为托管模式
   // 需要对 EventRunner 的实例进行校验，因为创建 EventRunner 可能失败，如创建线程失败时，创建 EventRunner 失败。
   if (runner == null) {
       return;
   }

创建 EventHandler 子类的实例。

MyEventHandler myHandler = new MyEventHandler(runner);

获取 InnerEvent 事件。

 // 获取事件实例，其属性 eventId, param, object 由开发者确定，代码中只是示例。
   int eventId1 = 0;
   int eventId2 = 1; 
   long param = 0; 
   Object object = null; 
   InnerEvent event1 = InnerEvent.get(eventId1, param, object);
   InnerEvent event2 = InnerEvent.get(eventId2, param, object);

投递事件，投递的优先级以 IMMEDIATE 为例，延时选择 0ms和 2ms。

 // 优先级 immediate，投递之后立即处理，延时为 0ms，该语句等价于同步投递sendSyncEvent(event1，EventHandler.Priority.immediate);
   myHandler.sendEvent(event1, 0, EventHandler.Priority.IMMEDIATE);
   myHandler.sendEvent(event2, 2, EventHandler.Priority.IMMEDIATE); // 延时 2ms 后立即处理

启动和停止 EventRunner，如果为托管模式，则不需要此步骤。

 runner.run();
   //待执行操作
   runner.stop();// 开发者根据业务需要在适当时机停止 EventRunner

EventHandler 投递 Runnable 任务

EventHandler 投递Runnable 任务，并按照优先级和延时进行处理，开发步骤如下：

创建 EventHandler 的子类，创建 EventRunner，并创建 EventHandler 子类的实例，步骤与[ EventHandler 投递 InnerEvent] 场景的步骤1-3相同。
创建 Runnable 任务。

  Runnable task1 = new Runnable() {
       @Override
       public void run() {
           // 待执行的操作，由开发者定义
       }
   };
   Runnable task2 = new Runnable() {
       @Override
       public void run() {
           // 待执行的操作，由开发者定义
       }
   };

投递 Runnable 任务，投递的优先级以 IMMEDIATE 为例，延时选择 0ms 和 2ms。

   //优先级为 immediate，延时 0ms，该语句等价于同步投递myHandler.postSyncTask(task1，EventHandler.Priority.immediate);
   myHandler.postTask(task1，0， EventHandler.Priority.IMMEDIATE);

    
   myHandler.postTask(task2，2， EventHandler.Priority.IMMEDIATE);// 延时2ms后立即执行

启动和停止 EventRunner，如果是托管模式，则不需要此步骤。

 runner.run();
   //待执行操作

    
   runner.stop();// 停止 EventRunner

在新创建的线程里投递事件到原线程

EventHandler 从新创建的线程投递事件到原线程并进行处理，开发步骤如下：

创建 EventHandler 的子类，在子类中重写实现方法 processEvent() 来处理事件。

 private class MyEventHandler extends EventHandler {
       private MyEventHandler(EventRunner runner) {
       super(runner);
       }
       // 重写实现processEvent方法
       @Override
       public void processEvent(InnerEvent event) {
       super.processEvent(event);
       if (event == null) {
               return;
       }
       int eventId = event.eventId;
       long param = event.param;
           Object object = event.object;
       switch (eventId | param) {
               case CASE1:
                   // 待执行的操作，由开发者定义
               break;
               case CASE2:
                   // 将原先线程的EventRunner实例投递给新创建的线程
                   if (object instanceof EventRunner) {
                   EventRunner runner2 = (EventRunner)object;
                   }
                   // 将原先线程的EventRunner实例与新创建的线程的EventHandler绑定
                   EventHandler myHandler2 = new EventHandler(runner2) {
                   @Override
                   public void processEvent(InnerEvent event) {
                  //需要在原先线程执行的操作
                   }
                   };
                   int eventId = 1; 
                   long param = 0; 
                   Object object = null; 
                   InnerEvent event2 = InnerEvent.get(eventId, param, object);
                   myHandler2.sendEvent(event2); // 投递事件到原先的线程
                   break;
           default:
           break;
       }
       }
   }

创建 EventRunner，以手动模式为例。

  EventRunner runner1 = EventRunner.create(false);// create()的参数是true时，则为托管模式。
   // 需要对 EventRunner 的实例进行校验，不是任何线程都可以通过 create 创建，例如：当线程池已满时，不能再创建线程。
   if (runner1 == null) {
       return;
   }

创建 EventHandler 子类的实例。

   MyEventHandler myHandler1 = new MyEventHandler(runner1);

获取 InnerEvent 事件。

 // 获取事件实例，其属性 eventId, param, object 由开发者确定，代码中只是示例。
   int eventId1 = 0;
   long param = 0; 
   Object object = (Object) EventRunner.current();
   InnerEvent event1 = InnerEvent.get(eventId1, param, object);

投递事件，在新线程上直接处理。

 // 将与当前线程绑定的 EventRunner 投递到与 runner1 创建的新线程中  myHandler.sendEvent(event1);

启动和停止 EventRunner，如果是托管模式，则不需要此步骤。

 runner.run();
   //待执行操作

    
   runner.stop();// 停止 EventRunner

**完整代码示例

非托管情况：**

 //全局：
  EventRunner runnerA

   
  //线程A：
  runnerA = EventRunner.create(false);
  runnerA.run(); // run之后一直循环卡在这里，所以需要新建一个线程run

   
  //线程B：
  //1.创建类继承EventHandler
  public class MyEventHandler extends EventHandler {
      public static int CODE_DOWNLOAD_FILE1;
      public static int CODE_DOWNLOAD_FILE2;
      public static int CODE_DOWNLOAD_FILE3;
      private MyEventHandler(EventRunner runner) {
          super(runner);
      }

   
      @Override
      public void processEvent(InnerEvent event) {
          super.processEvent(event);
          if (event == null) {
              return;
          }

   
          int eventId = event.eventId;
          if (STOP_EVENT_ID != eventId) {
              resultEventIdList.add(eventId);
          }

   
          switch (eventId) {
              case CODE_DOWNLOAD_FILE1: {
                  ... // your process
                  break;
              }
              case CODE_DOWNLOAD_FILE1: {
                  ... // your process
                  break;
              }
              case CODE_DOWNLOAD_FILE1: {
                  ... // your process
                  break;
              }
              default:
                  break;
          }
      }
  }

   
  //2.创建 MyEventHandler 实例
  MyEventHandler handler = new MyEventHandler(runnerA);

   
  // 3.向线程 A 发送事件
  handler.sendEvent(CODE_DOWNLOAD_FILE1);
  handler.sendEvent(CODE_DOWNLOAD_FILE2);
  handler.sendEvent(CODE_DOWNLOAD_FILE3);
  ......

   
  // 4.runnerA 不再使用后，退出
  runnerA.stop();

托管情况：

 //1.创建 EventRunner A：
  EventRunner runnerA = EventRunner.create("downloadRunner"); // 内部会新建一个线程

   
  //2.创建类继承 EventHandler
  public class MyEventHandler extends EventHandler {
      public static int CODE_DOWNLOAD_FILE1;
      public static int CODE_DOWNLOAD_FILE2;
      public static int CODE_DOWNLOAD_FILE3;
      private MyEventHandler(EventRunner runner) {
          super(runner);
      }

   
      @Override
      public void processEvent(InnerEvent event) {
          super.processEvent(event);
          if (event == null) {
              return;
          }

   
          int eventId = event.eventId;
          if (STOP_EVENT_ID != eventId) {
              resultEventIdList.add(eventId);
          }

   
          switch (eventId) {
              case CODE_DOWNLOAD_FILE1: {
                  ... // your process
                  break;
              }
              case CODE_DOWNLOAD_FILE1: {
                  ... // your process
                  break;
              }
              case CODE_DOWNLOAD_FILE1: {
                  ... // your process
                  break;
              }
              default:
                  break;
          }
      }
  }

   
  //3.创建MyEventHandler实例
  MyEventHandler handler = new MyEventHandler(runnerA);

   
  //4.向线程A发送事件
  handler.sendEvent(CODE_DOWNLOAD_FILE1);
  handler.sendEvent(CODE_DOWNLOAD_FILE2);
  handler.sendEvent(CODE_DOWNLOAD_FILE3);
  ......

   
  //5.runnerA没有任何对象引入时，线程会自动回收
  runnerA = null;

原文地址：https://blog.csdn.net/weixin_51705943/article/details/141994329

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：如何解决“json schema validation error ”错误？ -- HarmonyOS自学6
下一篇：TensorRT-LLM——优化大型语言模型推理以实现最大性能的综合指南

leetcode刷题day25|回溯算法Part04（491.递增子序列、46.全排列、47.全排列 II）
全排列树层树枝的去重有点难理解
阅读更多2024-09-22
【60天备战2024年11月软考高级系统架构设计师——第23天：系统架构设计原则——模块化设计】
模块化设计是一种将系统划分为若干独立模块的设计方式，每个模块都具备相对独立的功能，可以单独开发、测试和维护。模块化设计的核心思想是通过模块的划分，减少系统的复杂度，提升系统的可扩展性和可维护性。
阅读更多2024-09-22
职业技能大赛-自动化测试笔记分享-2
Web自动化测试是使用软件工具自动执行对Web应用程序的测试，以提高效率和准确性。它通常涉及编写测试脚本，模拟用户交互，并验证应用程序的功能、性能和安全性。常用的工具包括 Selenium、Cypre
阅读更多2024-09-22
TCP/IP协议详解：现代网络通信的基石
在本文中，我们将深入探讨TCP/IP协议的工作原理、其四层模型的结构，以及它如何实现可靠的数据传输。
阅读更多2024-09-22
Qt/C++开发经验
Qt在开发阶段不支持中文目录（运行阶段可以，比如打包发布的程序放到中文目录运行是ok的），切记，这是无数人可能犯的错误，在安装Qt集成开发环境以及编译器的时候，务必记得目录必须英文，Qt项目源码也必须
阅读更多2024-09-22
C++ | Leetcode C++题解之第414题第三大的数
C++ | Leetcode C++题解之第414题第三大的数
阅读更多2024-09-22
在 Debian 12 上安装 Java 21
在 Debian 12 上安装 Java 21 可以通过以下两种主要方法：使用 Oracle JDK 21下载 deb 包：从 Oracle 官方网站下载适用于 Linux 的 Java 21 的 d
阅读更多2024-09-22
【前端】prop传值的用法
props是只读的，如果需要修改可以复制props中的内容到data中一份，然后去修改data中的数据。因为vue底层会检测对props的修改，如果进行了修改，就会发出警告。prop配置项的作用是让组
阅读更多2024-09-22
微信支付开发-后台统计工厂实现
微信支付开发-后台统计工厂实现-thinkphp6+MySQL5.7
阅读更多2024-09-22
攻防世界----＞Windows_Reverse1（补）
decode 取值等于 byte_ [xxx] 是否说明了byte_ 是一张解密表？总结：最好自己分析，不要纠结表的数据，为什么不一样。以自己的hex数据为准。假设，我们不知道地址随机怎么办？不能动调
阅读更多2024-09-22

鸿蒙OS 线程间通信

鸿蒙OS 线程间通信概述

鸿蒙OS 线程间通信开发指导

相关文章