HarmonyOS应用开发实战：ArkTS语言踩坑解决方案

TaskPool、Worker和各个ArkTS引擎实例之间是否内存隔离

TaskPool和Worker基于Actor模型实现并发，Actor模型具备内存隔离的特性，所以TaskPool、Worker和各个ArkTS引擎实例之间是内存隔离的。

在TaskPool的生命周期中TaskPool线程什么时候会被销毁

TaskPool的生命周期无需开发者手动去管理。有一定时间没有执行新的任务，或者在TaskPool线程上没有执行监听任务的情况下，线程可能会被销毁。

TaskPool对于任务时间有没有限制

任务时常上限3分钟（不包含Promise和async/await异步调用的耗时）。

对于预加载任务量大的场景推荐使用Worker还是TaskPool

Worker存在数量限制，支持最多同时存在8个Worker。所以针对预加载任务量大的场景，推荐使用TaskPool。

存在线程复用的并发场景，推荐使用Worker还是TaskPool

同一个Worker无法执行不同的任务，所以针对线程复用的并发场景，推荐使用TaskPool。

是否可以在TaskPool中动态加载模块（Har、Hsp、So）？(API 10)

解决方案

可以，TaskPool动态加载能力跟主线程能力一致。但是TaskPool线程加载后，由于模块化线程隔离的缘故，不能给主线程复用。

如何实现多线程数据共享？(API 10)

原理澄清

由于ArkTS是单线程模型，内存隔离，因此大部分普通对象跨线程均采用序列化方式。

解决方案

目前部分支持共享的对象如下: 通过ArrayBuffer的转移传输和SharedArrayBuffer进行共享。

线程间JS对象的数据通信依赖序列化方式，是否存在性能问题？(API 10)

原理澄清

目前线程间对象的数据通信依赖序列化、反序列化，耗时与数据量相关，需要控制传输的数据量，或者采用ArrayBuffer或者SharedArrayBuffer的转移或者共享。

Worker可用线程数量少，无法满足应用平移适配需求，部分应用可能超过200个线程。 TaskPool和Worker都无法提供对等的线程数量，应该如何设计大量线程并发方案？(API 10)

解决方案

系统采用ArkTS作为开发语言，由于底层线程模型对接了libuv，因此在应用进程启动后，会有多个I/O线程用于I/O操作，JS线程的I/O异步操作，会在I/O线程执行，JS线程可以同时执行其他操作，不存在阻塞等待问题。 同时，ArkTS提供了TaskPool并发API，类似GCD的线程池能力，可以执行任务，而且不需要开发者进行线程生命周期管理。 因此针对需要大量线程的问题，开发建议如下: 将多线程任务转变为并发任务，通过TaskPool分发执行 I/O型任务不需要单独开启线程，而是在当前线程（可以是TaskPool线程）执行 少量需要常驻的CPU密集型任务，采用Worker，并且需要控制在8个及以下。

并发任务的调度及实时性问题，如何设置Task优先级，各个优先级的调度策略有什么区别，原理是什么，分别推荐在什么场景使用？(API 10)

解决方案

当前支持设置任务优先级，同一任务重复执行的顺序和优先级没关系，主要看任务执行的顺序，不同任务指定不同优先级示例如下：

代码示例

@Concurrent
function printArgs(args: number): number {
  let t: number = Date.now();
  while (Date.now() - t < 1000) { // 1000: delay 1s
    continue;
  }
  console.info("printArgs: " + args);
  return args;
}

let allCount = 100; // 100: test number
let taskArray: Array<taskpool.Task> = [];
// 创建300个任务并添加至taskArray
for (let i: number = 1; i < allCount; i++) {
  let task1: taskpool.Task = new taskpool.Task(printArgs, i);
  taskArray.push(task1);
  let task2: taskpool.Task = new taskpool.Task(printArgs, i * 10); // 10: test number
  taskArray.push(task2);
  let task3: taskpool.Task = new taskpool.Task(printArgs, i * 100); // 100: test number
  taskArray.push(task3);
}

// 从taskArray中获取不同的任务并给定不同优先级执行
for (let i: number = 0; i < allCount; i+=3) { // 3: 每次执行3个任务，循环取任务时需后移3项，确保执行的是不同的任务
  taskpool.execute(taskArray[i], taskpool.Priority.HIGH);
  taskpool.execute(taskArray[i + 1], taskpool.Priority.LOW);
  taskpool.execute(taskArray[i + 2], taskpool.Priority.MEDIUM);
}
ts

如何将内存共享的线程模型，转换成在ArkTS的线程模型下（内存隔离）的实现方式？(API 11)

解决方案

可以利用TaskPool接口转换，大概可以分为如下五个场景。

场景一：主线程将独立的耗时任务放到子线程执行
代码示例：
共享内存写法

class Task {
  static run(args) {
    // Do some independent task
  }
}

let thread = new Thread(() => {
  let result = Task.run(args)
  // deal with result
})
ts

ArkTS写法

import taskpool from '@ohos.taskpool'
@Concurrent
function run(args: string) {
  // Do some independent task
}

let args: string = '';
let task = new taskpool.Task(run, args)
taskpool.execute(task).then((ret: string) => {
  // Return result
})
ts

场景二：主线程将创建的类对象实例在子线程使用
代码示例：
共享内存写法

class Material {
  action(args) {
    // Do some independent task
  }
}

let material = new Material()
let thread = new Thread(() => {
  let result = material.action(args)
  // deal with result
})
ts

ArkTS写法

import taskpool from '@ohos.taskpool'
@Concurrent
function runner(material: Material, args: string): void {
  return material.action(args);
}
@Sendable
class Material {
  action(args: string) {
    // Do some independent task
  }
}

let material = new Material()
taskpool.execute(runner, material).then((ret: string) => {
  // Return result
})
ts

场景三：主线程将独立的耗时任务放到子线程执行
代码示例：

class Task {
  run(args) {
    // Do some independent task
    task.result = true
  }
}

let task = new Task()
let thread = new Thread(() => {
  let result = task.run(args)
  // deal with result
})
ts

ArkTS写法

import taskpool from '@ohos.taskpool'
@Concurrent
function runner(task: Task) {
  let args: string = '';
  task.run(args);
}
@Sendable
class Task {
  result: string = '';

  run(args: string) {
    // Do some independent task
    return true;
  }
}

let task = new Task();
taskpool.execute(runner, task).then((ret: string) => {
  task.result = ret;
})
ts

场景四：子线程主动更新主线程状态
代码示例：

class Task {
  run(args) {
    // Do some independent task
    runOnUiThread(() => {
      UpdateUI(result)
    })
  }
}

let task = new Task()
let thread = new Thread(() => {
  let result = task.run(args)
  // deal with result
})
ts

ArkTS写法

import taskpool from '@ohos.taskpool'
@Concurrent
function runner(task) {
  task.run()
}

@Sendable
class Task {
  run(args) {
    // Do some independent task
    taskpool.Task.sendData(result)
  }
}

let task = new Task()
let run = new taskpool.Task(runner, task)
run.onReceiveData((result) => {
  UpdateUI(result)
})
taskpool.execute(run).then((ret) => {
  // Return result
})
ts

场景五：子线程同步调用主线程的接口
代码示例：

class SdkU3d {
  static getInst() {
    return SdkMgr.getInst();
  }

  getPropStr(str: string) {
    return xx;
  }
}

let thread = new Thread(() => {
  // 游戏线程
  let sdk = SdkU3d.getInst()
  let ret = sdk.getPropStr("xx")
})
ts

ArkTS写法

// 主线程
class SdkU3d {
  static getInst() {
    return SdkMgr.getInst();
  }

  getPropStr(str: string) {
  }
}

const workerInstance = new
worker.ThreadWorker("xx/worker.ts");
let sdk = SdkU3d.getInst()
workerInstance.registerGlobalCallObject("instance_xx", sdk);
workerInstance.postMessage("start");
const mainPort = worker.workerPort;
mainPort.onmessage = (e: MessageEvents): void => {
  let ret = mainPort.callGlobalCallObjectMethod("instance_xx", "getPropStr", "xx");
}
ts

TaskPool和Worker的区别是什么，分别推荐在什么场景下使用？(API 10)

概念澄清

两者是不同颗粒度的并发API，Worker更像Thread或者Service维度，Task就是单一任务维度。
同时TaskPool简化开发者开发并发程序，支持优先级和取消，并且通过统一管理节省系统资源优化调度。

相同点是：在JS相关的线程间交互上，二者本质都是内存隔离模型，参数与范围值的限制是一致的，也有开销。（需注意并发任务粒度）

Worker和TaskPool的线程数量是否都有限制，如果超过会如何？在使用时，是否会相互影响，如Worker在达到上限数量时，会影响TaskPool吗？(API 10)

规格澄清

TaskPool内部会动态调整线程个数，不支持设置数量，只需要往线程池中抛任务，确保高优先级任务的及时执行。
Worker的线程个数最多8个，如果Worker超过规定个数，会创建失败。
TaskPool与Worker不影响。两者独立，Worker是固定数量，当前是8个。TaskPool线程池的数量会根据硬件条件、任务负载等情况动态调整。

是否有线程安全的容器类？(API 10)

原理澄清

因为没有对象直接共享，所以容器都是线程安全的

TaskPool，Worker中任务调度机制是什么？是否和JS单线程的事件循环机制一样的？先执行完微任务队列，再执行宏任务？(API 10)

原理澄清

TaskPool与Worker采用事件事件循环接收线程间通信的消息。 Worker不支持消息的优先级。 TaskPool中的任务支持优先级设置，会影响消息的处理优先级。

系统多线程模型是什么样的？(API 10)

解决方案

ArkTS主要提供TaskPool API支持多线程开发，常驻耗时任务还可以使用Worker，但是Worker有数量限制，当前最大数量是8个Worker。 Native侧建议使用FFRT线程池，pthread暂无限制。

是否支持Context跨线程传递？(API 10)

规格澄清

支持，可以直接将Context作为参数传递

在多线程并发场景中，如何实现安全访问同一块共享内存？(API 10)

规格澄清

可以使用共享对象SharedArrayBuffer实现。SharedArrayBuffer对象存储的数据在同时被修改时，需要通过Atomics原子操作保证其同步性，即下个操作开始之前务必需要等到上个操作已经结束。

代码示例

// index.ets
let sab = new SharedArrayBuffer(32);
// int32 buffer view for sab
let i32a = new Int32Array(sab);
i32a[0] = 0;

let producer = new worker.ThreadWorker("entry/ets/workers/worker_producer.ts");
producer.postMessage(sab);

function consumection(e: MessageEvents) {
  let sab: SharedArrayBuffer = e.data;
  let i32a = new Int32Array(sab);
  console.info("Customer: received sab");
  while (true) {
    Atomics.wait(i32a, 0, 0); //blocked here until be waked.
    let length = i32a.length;
    for (let i = length - 1; i > 0; i--) {
      console.info("arraybuffer " + i + " value is " + i32a[i]);
      i32a[i] = i;
    }
  }
}
ts

子线程和主线程相比，谁的优先级更高，任务执行策略是什么？(API 10)

原理澄清

主线程作为UI线程，拥有最高优先级。在负载较高时，执行会更快；负载较低时，效率差别不大。 子线程可以通过优先级设置，任务优先级等影响调度。

ArkTS是否有全局强制切换线程执行和调度的接口？(API 10)

规格澄清

Worker支持通过PostMessage往父线程抛任务。TaskPool支持往父线程发消息，触发任务。

ArkTS是否支持共享内存模型进行多线程开发吗？(API 10)

规格澄清

无法做到通过加锁的方式实现多个线程同时对同一个内存对象的同时操作。ArkTS是Actor并发模型，线程间内存隔离，当前只支持SharedArrayBuffer或者Native层对象的共享。

ArkTS的SendableClass对象内存共享的原理是什么？有什么限制？如何使用？(API 11)

原理澄清

SendableClass是基于Actor内存隔离并发模型的扩展，Sendable对象的内存是线程间共享的，但是仍然需要满足单线程无锁化运行。因此，要保证同一个Sendable实例不能多线程并发访问，开发者需要通过同步机制保证线程安全。

规格澄清

Sendable对象需要满足一定的规格：

1. 成员属性为 Sendable类 或者基础类型（string number boolean等，Array等容器类待扩展后支持）
2. 成员属性必须显式初始化
3. 成员函数不能使用闭包，只能使用入参 或者 this成员 或者 import导入的变量
4. 只允许Sendable类继承Sendable类
5. @Sendable只能写在ArkTS(ets)文件中
6. 不支持#定义私有属性，要用private
7. 导出Sendable类的文件，不能导出非Sendable属性
8. 传输方式有如下两种：     8.1 序列化传递：深拷贝到其他线程，非共享模式。     8.2 共享模式：可以跨线程引用传递，多线程可同时读写，开发者需要自行采用同步机制避免多线程竞争。

ArkTs类的方法是否支持重载？怎么实现？(API 10)

解决方案

当前ArkTS支持TS中的重载，即多个重载签名 + 实现签名 + 函数体的形式。函数签名只用在编译期进行类型检查，不保留到运行时。 ArkTS不支持多个函数体实现的重载。

示例：

系统里的线程机制是怎么样的？每个线程是一个单独的JS引擎吗？如果每个线程开销比较小的话，为啥要限制线程数量？(API 10)

原理澄清

设备的核数有限，线程数泛滥引起调度开销和内存开销。
系统提供了ArkTS任务池和FFRT任务池支持系统统一调度。
系统ArkTS线程中JS部分是基于内存隔离的Actor模型实现，每个线程拥有单独的JS环境实例，因此开启线程会有较大的内存开销。
另外设备的核数有限，其他系统应用线程数开得过多是因为同步锁、同步I/O编程的方式导致。
系统提供的异步I/O调用均分发到I/O线程池，不会阻塞应用线程，因此不需要独占线程调用I/O，所需的线程数量远小于其他操作系统。

TaskPool在任务执行过程中如何跟主线程进行通信？如何操作同一块内存变量？(API 10)

解决方案

TaskPool的任务支持通过sendData接口触发主线程的onReceiveData回调。
当前多个线程之间支持通过SharedArrayBuffer进行同一块内存的操作。

对于多线程操作首选项和数据库是不是线程安全的？(API 10)

解决方案

是线程安全的。

如果在ArkTS中大部分后台任务（计算、埋点、入库）都使用异步并发的方式，会不会使主线程越来越慢，引起卡顿丢帧问题？(API 10)

解决方案

ArkTS层接口的异步如果不涉及I/O操作，则异步任务会在主线程的微任务执行时机触发，仍然占用主线程。推荐使用TaskPool，分发到后台任务池进行。

如何简单实现函数的同步调用功能?(API 10)

解决方案

当前不支持关键字修饰的同步机制。后续会支持AsyncLock形式的同步机制，支持将需要同步的代码块放到异步代码块中。

在ArkTS的主线程中使用await会堵塞主线程吗？（API 10）

比如如下代码在主线程中执行：
const response = await reqeust.buildCall().execute<string>();
这种写法会导致主线程堵塞吗？

解决方案

并不会。await会挂起当前异步任务，等异步任务满足条件后再唤醒执行，主线程可以处理其他任务。

当使用C/C++进行开发时，如何实现在子线程中直接调用H系统SDK提供的TS接口，而不是post到主线程上？（API 10）

解决方案

当前还不支持。

系统使用了ArkTS作为开发语言，那这些代码的在底层的解释运行的环境是自研的还是用的开源的？另外系统也适配了React Native引擎，是不是也是复用的这个运行环境？（API 10）

解决方案

1. 系统ArkTS语言运行在自研的方舟编译运行时，运行的是应用包中经过方舟编译工具链编译ArkTS/TS/JS源码后生成的字节码。
2. 系统适配的React Native引擎目前仍是运行JS源码，运行在系统提供的V8引擎。

ArkTS里的数据类型转换方法有哪些？和TS是一致的吗？（API 10）

解决方案

ArkTS支持TS语义的as类型转换，不支持使用<>运算符进行类型转换。当前as类型转换只用在编译时，无法通过as在运行时进行类型转换。 ArkTS支持内置的类型转换函数，例如Number(), String(), Boolean()等。

TaskPool后台I/O任务池，应用能否自行做管控？有无方法开放管理机制？（API 10）

解决方案

1. TaskPool后台线程是根据负载及硬件决定的，无法开放管理，只能支持串行队列，任务组等机制进行任务管控。
2. I/O任务池有底层进行调度，无法自行管控。

操作系统对TS文件开发后续还支持吗？（API 10）

问题描述

基础库实现基于TS实现后续能否兼容？比如TS支持any，以及运行时动态类型转换，但是ets文件不支持。

解决方案

操作系统将持续支持标准TS语法，兼容现有TS实现的三方库。

是否支持模块的动态加载？如何实现？（API 10）

解决方案

当前不支持动态加载设备侧的二进制包；可以使用动态import进行异步加载，达到类似于Class.forName()反射的效果。 实例如下，hap动态import harlibrary，并调用静态成员函数staticAdd()、实例成员函数instanceAdd()，以及全局方法addHarLibrary()

// harlibrary的src/main/ets/utils/Calc.ets
export class Calc {
  public constructor() {}
  public static staticAdd(a: number, b: number): number {
    let c = a + b;
    console.log("DynamicImport I'm harLibrary in staticAdd, %d + %d = %d", a, b, c);
    return c;
  }
  public instanceAdd(a: number, b: number): number {
    let c = a + b;
    console.log("DynamicImport I'm harLibrary in instanseAdd, %d + %d = %d", a, b, c);
    return c;
  }
}

export function addHarLibrary(a: number, b: number): number {
  let c = a + b;
  console.log("DynamicImport I'm harLibrary in addHarLibrary, %d + %d = %d", a, b, c);
  return c;
}

// harlibrary的index.ets
export { Calc, addHarLibrary } from './src/main/ets/utils/Calc';

// hap的index.ets
let harLibrary = 'harlibrary';
import(harLibrary).then((ns: ESObject) => {  // 动态import变量是新增特性，入参换成字符串'harlibrary'是现有特性。也可使用await import方式。
  ns.Calc.staticAdd(7, 8);  // 反射调用静态成员函数staticAdd()
  let calc: ESObject = new ns.Calc();  // 实例化类Calc
  calc.instanceAdd(8, 9);  // 调用实例成员函数instanceAdd()
  ns.addHarLibrary(6, 7);  // 调用全局方法addHarLibrary()
});
ts

ArkTS是否可以开发AST数据结构或者接口？(API 11)

解决方案

AST属于编译器编译过程中间数据结构，该数据本身不稳定，可能会随着语言或者编译器的演进发生变化，暂无计划开放给开发者。

开发者如果有二进制扫描相关需求，可以参考下方链接。

目前系统的多线程内存占用大，每个线程需要一个ArkTS引擎，意味着更多的内存占用。如何解决应用需要避免开辟过多线程，并发处理任务数量受限，无法充分发挥设备性能的问题？

原理澄清

当前ArkTS创建线程(worker)会创建一个新的ArkTS引擎实例，会占用额外的内存。

同时，ArkTS提供了TaskPool并发API，类似GCD的线程池能力，可以执行任务，而且不需要开发者进行线程生命周期管理。Task会被调度到有限数量的工作线程执行，多个task会共享这些工作线程（ArkTS引擎实例），系统会根据负载情况扩容/缩容工作线程的数量，充分发挥硬性性能。

解决方案

因此针对需要大量线程的问题，应用的开发建议如下:

1. 将多线程任务转变为并发任务，通过TaskPool分发执行。
2. I/O型任务不需要单独开启线程，而是在当前线程（可以是TaskPool线程）执行。
3. 少量需要常驻的CPU密集型任务，采用Worker，并且需要控制在8个及以下。

taskpool线程中是否可以使用emitter.on等长时间监听接口

不推荐。

原理澄清

1. 由于长时间的监听，可能会影响线程回收或复用。
2. 如果线程被回收会导致线程回调失效或者发生不可预期的错误。
3. 如果任务函数多次执行，可能会在不同的线程产生监听，导致结果不符合预期。

最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？但是又不知道从哪里下手，而且学习时频繁踩坑，最终浪费大量时间。所以本人整理了一些比较合适的鸿蒙（HarmonyOS NEXT）学习路径和一些资料的整理供小伙伴学习

点击领取→纯血鸿蒙Next全套最新学习资料希望这一份鸿蒙学习资料能够给大家带来帮助，有需要的小伙伴自行领取~~

一、鸿蒙（HarmonyOS NEXT）最新学习路线

​​

有了路线图，怎么能没有学习资料呢，小编也准备了一份联合鸿蒙官方发布笔记整理收纳的一套系统性的鸿蒙（OpenHarmony ）学习手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门教学视频，内容包含：（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）…等技术知识点。

获取以上完整版高清，请点击→纯血版全套鸿蒙HarmonyOS学习资料

二、HarmonyOS Next 最新全套视频教程

​​

三、《鸿蒙 (OpenHarmony)开发基础到实战手册》

OpenHarmony北向、南向开发环境搭建

​​

四、大厂面试必问面试题

​​

五、鸿蒙南向开发技术

​​

六、鸿蒙APP开发必备

​​
完整鸿蒙HarmonyOS学习资料，请点击→纯血版全套鸿蒙HarmonyOS学习资料

总结
总的来说，对于大家来说ye是一个挑战，也是一个机会。只有积极应对变化，不断学习和提升自己，他们才能在这个变革的时代中立于不败之地。