回复
鸿蒙 线程通信讲解
dmzhaoq1
发布于 2021-3-5 09:47
浏览
0收藏
三、线程通信
在开发过程中，开发者经常需要在当前线程中处理下载任务等较为耗时的操作，但是又不希望当前的线程受到阻塞。此时，就可以使用 EventHandler 机制。EventHandler 是HarmonyOS 用于处理线程间通信的一种机制，可以通过 EventRunner 创建新线程，将耗时的操作放到新线程上执行。这样既不阻塞原来的线程，任务又可以得到合理的处理。比如：主线程使用 EventHandler 创建子线程，子线程做耗时的下载图片操作，下载完成后，子线程通过 EventHandler 通知主线程，主线程再更新 UI。
① EventRunner
EventRunner 是一种事件循环器，循环处理从该 EventRunner 创建的新线程的事件队列中获取 InnerEvent 事件或者 Runnable 任务。InnerEvent 是 EventHandler 投递的事件。
EventHandler 是一种用户在当前线程上投递 InnerEvent 事件或者 Runnable 任务到异步线程上处理的机制。每一个 EventHandler 和指定的 EventRunner 所创建的新线程绑定，并且该新线程内部有一个事件队列。EventHandler 可以投递指定的 InnerEvent 事件或 Runnable 任务到这个事件队列。EventRunner 从事件队列里循环地取出事件，如果取出的事件是InnerEvent 事件，将在 EventRunner 所在线程执行 processEvent 回调；如果取出的事件是Runnable 任务，将在 EventRunner 所在线程执行 Runnable 的 run 回调。
② EventHandler
EventHandler 有两个主要作用：
- 在不同线程间分发和处理 InnerEvent 事件或 Runnable 任务。
- 延迟处理 InnerEvent 事件或 Runnable 任务。
EventHandler 的运作机制如下图所示：
使用 EventHandler 实现线程间通信的主要流程：
1、EventHandler 投递具体的 InnerEvent 事件或者 Runnable 任务到 EventRunner 所创建的线程的事件队列。
2、EventRunner 循环从事件队列中获取 InnerEvent 事件或者 Runnable 任务。
3、处理事件或任务：
① 如果 EventRunner 取出的事件为 InnerEvent 事件，则触发 EventHandler 的回调方法并触发 EventHandler 的处理方法，在新线程上处理该事件。
② 如果 EventRunner 取出的事件为 Runnable 任务，则 EventRunner 直接在新线程上处理 Runnable 任务。
1. 约束限制
在进行线程间通信的时候，EventHandler 只能和 EventRunner 所创建的线程进行绑定，EventRunner 创建时需要判断是否创建成功，只有确保获取的 EventRunner 实例非空时，才可以使用 EventHandler 绑定 EventRunner。
一个 EventHandler 只能同时与一个 EventRunner 绑定，一个 EventRunner 上可以创建多个 EventHandler。
2. 开发场景
EventHandler 的主要功能是将 InnerEvent 事件或者 Runnable 任务投递到其他的线程进行处理，其使用的场景包括
开发者需要将 InnerEvent 事件投递到新的线程，按照优先级和延时进行处理。投递时，EventHandler 的优先级可在IMMEDIATE、HIGH、LOW、IDLE 中选择，并设置合适的 delayTime。
开发者需要将 Runnable 任务投递到新的线程，并按照优先级和延时进行处理。投递时，EventHandler 的优先级可在IMMEDIATE、HIGH、LOW、IDLE 中选择，并设置合适的 delayTime。
开发者需要在新创建的线程里投递事件到原线程进行处理。
3. 工作模式
EventRunner 的工作模式可以分为托管模式和手动模式。两种模式是在调用 EventRunner 的create()方法时，通过选择不同的参数来实现的，默认为托管模式。
托管模式：不需要开发者调用 run()和 stop()方法去启动和停止 EventRunner。当 EventRunner 实例化时，系统调用
run()来启动 EventRunner；当 EventRunner 不被引用时，系统调用 stop()来停止 EventRunner。
手动模式：需要开发者自行调用 EventRunner 的 run()方法和 stop()方法来确保线程的启动和停止。
③ 接口说明
1. EventHandler
EventHandler 的属性 Priority(优先级)介绍：
EventRunner 将根据优先级的高低从事件队列中获取事件或者 Runnable 任务进行处理。
EventHandler 的主要接口介绍：
2. EventRunner
EventRunner 的主要接口介绍：
3. InnerEvent
InnerEvent 的属性介绍：
InnerEvent 的主要接口介绍：
④ 开发步骤
一、EventHandler 投递 InnerEvent 事件
EventHandler 投递 InnerEvent 事件，并按照优先级和延时进行处理，创建一个MyEventHandler类型继承EventHandler
package com.llw.thread.event;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;
import ohos.eventhandler.InnerEvent;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;
public class MyEventHandler extends EventHandler {
/**
* 日志
*/
private static final HiLogLabel label = new HiLogLabel(3, 0xD001100, "ThreadDemo");
public MyEventHandler(EventRunner runner) throws IllegalArgumentException {
super(runner);
}
/**
* 1. 创建 EventHandler 的子类，在子类中重写实现方法 processEvent()来处理事件
*
* @param event
*/
@Override
protected void processEvent(InnerEvent event) {
super.processEvent(event);
if (event == null) {
return;
}
int eventId = event.eventId;
long param = event.param;
switch ((int) (eventId | param)) {
case 1:
HiLog.info(label, "eventId | param --->" + 1);
break;
default:
break;
}
}
/**
* EventHandler 投递 InnerEvent 事件
*/
private void initInnerEvent() {
//2. 创建 EventRunner，以手动模式为例。
// create()的参数是 true 时，则为托管模式
EventRunner runner = EventRunner.create(false);
if (runner == null) {
return;
}
//3. 创建 EventHandler 子类的实例。
MyEventHandler myHandler = new MyEventHandler(runner);
//4. 获取 InnerEvent 事件。
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);
//5. 投递事件，投递的优先级以 IMMEDIATE 为例，延时选择 0ms 和 2ms。
myHandler.sendEvent(event1, 0, EventHandler.Priority.IMMEDIATE);
// 延时 2ms 后立即处理
myHandler.sendEvent(event2, 2, EventHandler.Priority.IMMEDIATE);
//6. 启动和停止 EventRunner，如果为托管模式，则不需要此步骤。
runner.run();
//待执行操作
// ... 执行业务逻辑
// 停止 EventRunner
runner.stop();
}
}
二、EventHandler 投递 Runnable 任务
/**
* EventHandler 投递 Runnable 任务
*/
private void initRunnable() {
//2. 创建 EventRunner，以手动模式为例。
// create()的参数是 true 时，则为托管模式
EventRunner runner = EventRunner.create(false);
if (runner == null) {
return;
}
//3. 创建 EventHandler 子类的实例。
MyEventHandler myHandler = new MyEventHandler(runner);
//2. 创建 Runnable 任务。
Runnable task1 = new Runnable() {
@Override
public void run() {
HiLog.info(label, "task1 running");
}
};
Runnable task2 = new Runnable() {
@Override
public void run() {
HiLog.info(label, "task1 running");
}
};
//3. 投递 Runnable 任务，投递的优先级以 IMMEDIATE 为例，延时选择 0ms 和 2ms。
myHandler.postTask(task1, 0, EventHandler.Priority.IMMEDIATE);
// 延时 2ms 后立即执行
myHandler.postTask(task2, 2, EventHandler.Priority.IMMEDIATE);
//4. 启动和停止 EventRunner，如果是托管模式，则不需要此步骤。
runner.run();
//待执行操作
// ... 执行业务逻辑
// 停止 EventRunner
runner.stop();
}
三、在新创建的线程里投递事件到原线程
修改MyEventHandler之后代码如下：
package com.llw.thread.event;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;
import ohos.eventhandler.InnerEvent;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;
public class MyEventHandler extends EventHandler {
/**
* 日志
*/
private static final HiLogLabel label = new HiLogLabel(3, 0xD001100, "ThreadDemo");
private MyEventHandler myHandler;
private EventRunner runner;
public MyEventHandler(EventRunner runner) throws IllegalArgumentException {
super(runner);
}
/**
* 1. 创建 EventHandler 的子类，在子类中重写实现方法 processEvent()来处理事件
*
* @param event
*/
@Override
protected void processEvent(InnerEvent event) {
super.processEvent(event);
if (event == null) {
return;
}
int eventId = event.eventId;
long param = event.param;
Object object = event.object;
switch ((int) (eventId | param)) {
case 1:
HiLog.info(label, "eventId | param --->" + 1);
break;
case 2:
EventRunner runner2 = null;
// 将原先线程的 EventRunner 实例投递给新创建的线程
if (object instanceof EventRunner) {
//强转
runner2 = (EventRunner) object;
}
// 将原先线程的 EventRunner 实例与新创建的线程的 EventHandler 绑定
EventHandler myHandler2 = new EventHandler(runner2) {
@Override
protected void processEvent(InnerEvent event) {
//需要在原先线程执行的操作
}
};
int eventId2 = 1;
long param2 = 0;
Object object2 = null;
InnerEvent event2 = InnerEvent.get(eventId2, param2, object2);
// 投递事件到原先的线程
myHandler2.sendEvent(event2);
break;
default:
break;
}
}
/**
* EventHandler 投递 InnerEvent 事件
*/
private void initInnerEvent() {
//2. 创建 EventRunner，以手动模式为例。
// create()的参数是 true 时，则为托管模式
runner = EventRunner.create(false);
if (runner == null) {
return;
}
//3. 创建 EventHandler 子类的实例。
myHandler = new MyEventHandler(runner);
//4. 获取 InnerEvent 事件。
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);
//5. 投递事件，投递的优先级以 IMMEDIATE 为例，延时选择 0ms 和 2ms。
myHandler.sendEvent(event1, 0, EventHandler.Priority.IMMEDIATE);
// 延时 2ms 后立即处理
myHandler.sendEvent(event2, 2, EventHandler.Priority.IMMEDIATE);
//6. 启动和停止 EventRunner，如果为托管模式，则不需要此步骤。
runner.run();
//待执行操作
// ... 执行业务逻辑
// 停止 EventRunner
runner.stop();
}
/**
* EventHandler 投递 Runnable 任务
*/
private void initRunnable() {
//2. 创建 EventRunner，以手动模式为例。
// create()的参数是 true 时，则为托管模式
runner = EventRunner.create(false);
if (runner == null) {
return;
}
//3. 创建 EventHandler 子类的实例。
myHandler = new MyEventHandler(runner);
//2. 创建 Runnable 任务。
Runnable task1 = new Runnable() {
@Override
public void run() {
HiLog.info(label, "task1 running");
}
};
Runnable task2 = new Runnable() {
@Override
public void run() {
HiLog.info(label, "task1 running");
}
};
//3. 投递 Runnable 任务，投递的优先级以 IMMEDIATE 为例，延时选择 0ms 和 2ms。
myHandler.postTask(task1, 0, EventHandler.Priority.IMMEDIATE);
// 延时 2ms 后立即执行
myHandler.postTask(task2, 2, EventHandler.Priority.IMMEDIATE);
//4. 启动和停止 EventRunner，如果是托管模式，则不需要此步骤。
runner.run();
//待执行操作
// ... 执行业务逻辑
// 停止 EventRunner
runner.stop();
}
/**
* 在新创建的线程里投递事件到原线程
*/
private void initNewToOld() {
//2. 创建 EventRunner，以手动模式为例。
// create()的参数是 true 时，则为托管模式。
EventRunner runner1 = EventRunner.create(false);
// 需要对 EventRunner 的实例进行校验，不是任何线程都可以通过 create 创建，例如：当线程池已满时，不能再创建线程。
if (runner1 == null) {
return;
}
//3. 创建 EventHandler 子类的实例。
MyEventHandler myHandler1 = new MyEventHandler(runner1);
//4. 获取 InnerEvent 事件。
// 获取事件实例，其属性 eventId, param, object 由开发者确定，代码中只是示例。
int eventId1 = 0;
long param = 0;
Object object = (Object) EventRunner.current();
InnerEvent event1 = InnerEvent.get(eventId1, param, object);
//5. 投递事件，在新线程上直接处理。
// 将与当前线程绑定的 EventRunner 投递到与 runner1 创建的新线程中
myHandler.sendEvent(event1);
//6. 启动和停止 EventRunner，如果是托管模式，则不需要此步骤。
runner.run();
//待执行操作
// ... 执行业务逻辑
// 停止 EventRunner
runner.stop();
}
}
四、结语
说实话弄起来缺是有点绕，这篇文章就到这里了，水平不高技术有限，初学者，不忘初心。
分类
已于2021-3-5 09:47:34修改
赞
收藏
回复
相关推荐
