【HarmonyOS NEXT】ArkTS 线程模型解析与使用

1. 前置学习文档

• 1.1 【HarmonyOS NEXT】ArkTs数据类型解析与使用
• 1.2 【HarmonyOS NEXT】ArkTs函数、类、接口、泛型、装饰器解析与使用
• 1.3 【HarmonyOS NEXT】ArkTs 模块的导出和引入
• 1.4 【HarmonyOS NEXT】异步编程的神器之Promise

2. 前言

在了解 ArkTS 线程模型之前，先了解几组易混淆的概念。

2.1 名词解释

• 进程（Process）：进程是系统资源分配和调度的单元。一个运行着的程序就对应了一个进程。一个进程包括了运行中的程序和程序所使用到的内存和系统资源。

  • 目前HarmonyOS 当前不支持手动创建进程；应用中（同一Bundle名称）的所有UIAbility、ServiceExtensionAbility和DataShareExtensionAbility 等其它Ability均是运行在同一个独立进程（主进程）中；
  • 关于HarmonyOS中的进程模型，可点击这里阅读：https://developer.huawei.com/consumer/cn/doc/harmonyos-guides...​
    线程（Thread）：线程是进程下的执行者，一个进程至少开启一个线程（主线程），也可以开启多个线程。

• 线程（Thread）：线程是进程下的执行者，一个进程至少开启一个线程（主线程），也可以开启多个线程。

  并行和并发的概念：

  • 并行（Parallelism）：指程序的运行状态，在同一时间内有几件事情并行在处理。由于一个线程在同一时间只能处理一件事情，所以并行需要多个线程在同一时间执行多件事情。​
  • 并发（Concurrency）：指程序的设计结构，在同一时间内多件事情能被交替地处理。重点是，在某个时间内只有一件事情在执行。比如单核 CPU 能实现多任务运行的过程就是并发。
    阻塞和非阻塞的概念：
  • 阻塞（Blocking）：阻塞是指调用在等待的过程中线程被挂起（CPU 资源被分配到其他地方去）
  • 非阻塞（Non-blocking）：非阻塞是指等待的过程 handlerCPU 资源还在该线程中，线程还能做其他的事情

  再来区分单线程和多线程的区别：

  • 单线程：从头执行到尾，逐行执行，如果其中一行代码报错，那么剩下代码将不再执行。同时容易代码阻塞。
  • 多线程：代码运行的环境不同，各线程独立，互不影响，避免阻塞。

  同步与异步的概念：

  • 同步（Synchronous）：程序发出调用的时候，一直等待直到返回结果，没有结果之前不会返回。也就是，同步时调用者主动等待调用过程，且能立即得到结果的。​
  • 异步（Asynchronous）：程序发出调用之后，无法立即得到结果，需要额外的操作才能得到预期的结果是为异步。

2.2 ArkTS 运行环境

  ArkCompiler eTS Runtime，类似于 Java 中的执行引擎 JVM【负责 Java 字节码的解析和执行】，Chrome Webkit 中 JavaScript 的执行引擎 V8 引擎【负责 JavaScript 代码的解析和执行】。

  它的大致流程就是先通过 ArkCompiler 将 ArkTS/TS/JS 程序预先静态编译为方舟字节码，在真机上使用 ets_runtime 运行方舟字节码【负责 ArkTS 字节码的解析和执行】。

• ets_runtime 源码地址：https://gitee.com/openharmony/arkcompiler_ets_runtime
• ets_runtime 源码部分目录

3. 线程模型

本文涉及到的线程模型主要是基于官方的应用模型>Stage 模型。更多应用模型可点击这里:
https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V13/application-models-V13

3.1 概述

Stage 模型下的线程主要有如下三类：

• 主线程

  • 执行 UI 绘制。
  • 管理主线程的 ArkTS 引擎实例，使多个 UIAbility 组件能够运行在其之上。
  • 管理其他线程的 ArkTS 引擎实例，例如使用 TaskPool（任务池）创建任务或取消任务、启动和终止 Worker 线程。
  • 分发交互事件。
  • 处理应用代码的回调，包括事件处理和生命周期管理。
  • 接收 TaskPool 以及 Worker 线程发送的消息。

• TaskPool Worker线程

  • 用于执行耗时操作，支持设置调度优先级、负载均衡等功能，推荐使用。

• Worker线程

  • 用于执行耗时操作，支持线程间通信。
    TaskPool与Worker的运作机制、通信手段和使用方法可以参考TaskPool和Worker的对比。

3.2 Stage 模型>主线程

  从上述资料中，我们不难发现 ArkTS 的线程机制还是依托于 JavaScript 来实现的。而 JavaScript 是一门单线程语言，所谓单线程，是指在 JS 引擎中负责解释和执行 JavaScript 代码的线程只有一个。不妨叫它主线程。

  但是实际上还存在其他的线程。例如：处理 Http 网络请求的线程、处理 UI 事件的线程、定时器线程、读写文件的线程等等。这些线程可能存在于 JS 引擎之内，也可能存在于 JS 引擎之外，在此我们不做区分。不妨叫它们工作线程。

3.3 同步与异步

  既然 js 是单线程，那么只要有一个任务耗时很长，后面的任务都必须排队等着，会拖延整个程序的执行，为了解决这个问题，JavaScript 语言将任务的执行模式分为两种：同步和异步。

3.3.1 同步

假设存在一个函数 A：

function A(args...);

  如果在函数 A 返回的时候，调用者就能够得到预期结果（即拿到了预期的返回值或者看到了预期的效果），那么这个函数就是同步的。

例如：

let number=Math.abs(-666)
console.log(number);//控制台输出 666
console.log('你好');//控制台输出 你好

• 第一个函数返回时，就拿到了预期的返回值：666。
• 第二个函数返回时，就看到了预期的效果：在控制台打印了一个字符串。

所以这两个函数都是同步的。

3.2.2 异步

假设存在一个函数 A：

function A(args...);

  如果在函数 A 返回的时候，调用者还不能够得到预期结果，而是需要在将来通过一定的手段得到，那么这个函数就是异步的。
例如：

//执行一个异步的网络请求
const session = rcp.createSession();
session.post("http://example.com/post", "data to send").then((response) => {
  console.info(`Succeeded in getting the response ${response}`);
}).catch((err: BusinessError) => {
  console.error(`err: err code is ${err.code}, err message is ${JSON.stringify(err)}`);
});
console.log('你好');//控制台输出 你好

  在执行这段代码时，session.post 函数返回时，并不会立刻打印 response ，只有 session.post 底层C++代码请求网络完成后才会返回到then或者catch中。也就是说异步函数 session.post 执行很快，不会阻塞 console.log('你好') 的执行，但后面还有工作线程执行异步任务、通知主线程、主线程回调等操作，这个过程就叫做异步过程。

3.4 消息队列与事件循环

  上面讲到，异步过程中，工作线程在异步操作完成后需要通知主线程。那么这个通知机制是怎样实现的呢？答案是利用消息队列和事件循环。
用一句话概括：
工作线程将消息放到消息队列，主线程通过事件循环过程去取消息。

• 消息队列：消息队列是一个先进先出的队列，它里面存放着各种消息。
• 事件循环：事件循环是指主线程重复从消息队列中取消息、执行的过程。

   实际上，主线程只会做一件事情，就是从消息队列里面取消息、执行消息，再取消息、再执行。当消息队列为空时，就会等待直到消息队列变成非空。而且主线程只有在将当前的消息执行完成后，才会去取下一个消息。这种机制就叫做事件循环机制，取一个消息并执行的过程叫做一次循环。

看到这个是不是觉得很熟悉，在 Android 中也有一套类似于这套事件循环的机制，就是 Handler: [https://android.googlesource.com/platform/frameworks/base/+/m...]机制。

Kotlin 协程也有类似的实现类 kotlinx.coroutines.EventLoop: [https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/EventLoop.common.kt]

3.4.1 任务队列

  JavaScript 运行时，除了一个正在运行的主线程，引擎还提供一个任务队列（task queue），里面是各种需要当前程序处理的异步任务。（实际上，根据异步任务的类型，可分为宏任务(Macrotask)和微任务(Microtask)。)

3.4.1.1 任务（调用堆栈）

  JavaScript 代码执行时的函数调用会形成一个“调用堆栈”。当一个函数执行时，它会被添加到堆栈中，一旦完成，就会从堆栈中移除。

3.4.1.2 宏任务

事件的回调函数【比如 onClick、onScroll】、setTimeout、setInterval、I/O 操作、网络请求 等

  当异步事件（如用户点击、文件读取完成）发生时，与这些事件关联的回调函数会被添加到一个“任务队列”中。一旦调用堆栈为空，事件循环就会从队列中取出任务来执行。

3.4.1.3 微任务

promise.then 方法、Async/Await、Object.observe 等。

  另一种任务队列，用于处理诸如 Promise 回调这样的微任务（microtasks）。微任务队列在事件循环的每个阶段结束时都会被清空，这意味着微任务的优先级高于常规的异步任务（宏任务，macro-tasks）。

3.4.2 事件循环（Event Loop）

  首先，主线程会去执行所有的同步任务，此时可能会遇到需要异步处理的任务，例如 setTimeout、http 请求等，这需要交给其他线程处理，当其他线程处理完之后，再将回调函数放入任务队列。

  等到同步任务全部执行完，就会去看任务队列里面的异步任务。如果满足条件，那么异步任务就重新进入主线程开始执行，这时它就变成同步任务了。等到执行完，下一个异步任务再进入主线程开始执行。一旦任务队列清空，程序就结束执行。

  JavaScript 引擎怎么知道异步任务有没有结果，能不能进入主线程呢？答案就是引擎在不停地检查，一遍又一遍，只要同步任务执行完了，引擎就会去检查那些挂起来的异步任务，是不是可以进入主线程了。这种循环检查的机制，就叫做事件循环（Event Loop）。

 console.log('主线程开始！')​
 ​
 setTimeout(function() {​
     console.log('setTimeout完成！')​
 }, 10);​
 ​
 console.log('主线程结束！')​
 ​
 //主线程开始！​
 //主线程结束！​
 //setTimeout完成！​
 ​
 console.log('第一步');​
​
setTimeout(() => {​
  console.log('第二步');​
}, 0);​
​
console.log('第三步');​
​
 //第一步​
 //第三步​
 //第二步

3.4.2.1 事件循环流程图式

3.4.3 任务的执行顺序

在 ArkTS 中的事件循环由一个宏任务队列+多个微任务队列组成。
顺序是：同步任务 ---> 微任务 ---> 宏任务

3.4.3.1 案例演示 1-执行顺序详解

console.log(1);​
setTimeout(() => {​
  console.log(2);​
}, 0);​
​
const p = new Promise((resolve, reject) => {​
  console.log(3);​
  resolve("success"); // 标记为成功​
  console.log(4);​
});​
​
p.then((value) => {​
  console.log(value);​
});​
​
console.log(5);

通过上述的理论解释，将上面代码分为同步任务、微任务、宏任务三块，

将我们分析好的代码，分开放在相应的队列里，可得到以下代码执行的流程图示：

所以这个案例，最终得到的执行结果就是： 1 3 4 5 “success” 2

3.4.3.2 案例演示 2-微任务的插队过程

setTimeout(()=>{​
  console.log('第一个回调函数：宏任务1')​
  Promise.resolve().then(()=>{​
    console.log('第二个回调函数：微任务2')​
  })​
},0)​
Promise.resolve().then(()=>{​
  console.log('第三个回调函数：微任务1')​
  setTimeout(()=>{​
    console.log('第四个回调函数：宏任务2')​
  },0)​
})​
​
// 第三个回调函数：微任务1​
// 第一个回调函数：宏任务1​
// 第二个回调函数：微任务2​
// 第四个回调函数：宏任务2

打印的结果不是 一、二、三、四。是因为，在 JavaScript 中，微任务的优先级比宏任务高，也就是说，如果微任务队列和宏任务队列中都有任务需要执行，微任务会先于宏任务执行。

4.总结

• ArkTS是单线程【ArkTS 引擎主线程】运行的。
• ArkTS中的异步任务【setTimeout/setInterval/promise等其它任务】 中的任务执行也是在【ArkTS 引擎主线程】中运行的。如果运行耗时较长的任务，则会阻塞【ArkTS 引擎主线程】，导致UI在耗时任务结束之前无法操作，如果超过6秒及以上应用会崩溃，抛出THREAD_BLOCK或者APP_INPUT_BLOCK 异常，例如下面的代码会抛出 APP_INPUT_BLOCK 异常

import { systemDateTime } from '@kit.BasicServicesKit'
@Entry
@Component
struct Index {
  @State message: string = 'ArkTS'
  build() {
    Column() {
      Button('Run').onClick(() => {
        let result = 0
        let begin = systemDateTime.getTime()
        for (let i = 1; i < 1000000000; ++i) {
          result += (i + i) * i - i + 1.0 / i
        }
        let end = systemDateTime.getTime()
        this.message = `${result}\n${(end - begin).toString()}`
      })
      Text(this.message)
    }.width('100%')
  }
}