From a7aaf6cf80e9a1520abfa520cc4c696d8b2eab96 Mon Sep 17 00:00:00 2001 From: leo9001 Date: Wed, 25 Jun 2025 10:06:52 +0800 Subject: [PATCH] update arkts-v1.1-v1.2-concurrency-rules.md --- .../arkts-v1.1-v1.2-concurrency-rules.md | 442 ++++++++++++++---- 1 file changed, 342 insertions(+), 100 deletions(-) diff --git a/zh-cn/application-dev/quick-start/arkts-v1.1-v1.2-concurrency-rules.md b/zh-cn/application-dev/quick-start/arkts-v1.1-v1.2-concurrency-rules.md index 03151f5b00c..0c9df0b720c 100644 --- a/zh-cn/application-dev/quick-start/arkts-v1.1-v1.2-concurrency-rules.md +++ b/zh-cn/application-dev/quick-start/arkts-v1.1-v1.2-concurrency-rules.md @@ -58,8 +58,8 @@ const workerInstance: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/w **ArkTS1.2** ```typescript let eaw = new EAWorker(); -eaw.run(():void => { - console.info('hello, eaworker!'); +eaw.run(() => { + console.info("hello, eaworker!"); }); eaw.join(); @@ -75,16 +75,13 @@ eaw.join(); **ArkTS1.1** ```typescript -// test.ets -export let num = 1; -// shared.ets -'use shared' -export {num} from './test'; +"use shared" +export function test() {} ``` **ArkTS1.2** ```typescript -export let num = 1; +export function test() {} ``` ## 共享函数不需要use concurrent修饰 @@ -98,7 +95,7 @@ export let num = 1; **ArkTS1.1** ```typescript function func() { -'use concurrent' +"use concurrent" } ``` @@ -146,7 +143,7 @@ console.info(str); **ArkTS1.2** ```typescript -let arr = new Array(1, 2, 3); +let arr = new Array(1, 2, 3); let str = JSON.stringify(arr); console.info(str); ``` @@ -181,7 +178,6 @@ let int32 = new Int32Array(sab); **ArkTS1.1** ```typescript -import { taskpool } from '@kit.ArkTS'; @Concurrent function test() {} let result: Boolean = taskpool.isConcurrent(test); @@ -211,7 +207,6 @@ taskpool.execute(test); **ArkTS1.2** ```typescript function test() {} - taskpool.execute(test); ``` @@ -249,14 +244,14 @@ import { process } from '@kit.ArkTS'; let result = process.is64Bit(); let pro = new process.ProcessManager(); -let pres = pro.getUidForName('tool'); +let pres = pro.getUidForName("tool"); ``` **ArkTS1.2** ```typescript let result = StdProcess.is64Bit(); let pro = new StdProcess.ProcessManager(); -let pres = pro.getUidForName('tool'); +let pres = pro.getUidForName("tool"); ``` ## 移除taskpool setCloneList接口 @@ -269,50 +264,19 @@ let pres = pro.getUidForName('tool'); **ArkTS1.1** ```typescript -import { taskpool } from '@kit.ArkTS'; - -@Sendable -class BaseClass { - public str: string = 'sendable: BaseClass'; -} - -@Concurrent -function testFunc(array: Array) { - let baseInstance = array[0]; - console.info('sendable: str1 is: ' + baseInstance.str); - return baseInstance.str; -} - -let baseInstance: BaseClass = new BaseClass(); -let array = new Array(); -array.push(baseInstance); -let task = new taskpool.Task(testFunc, array); -task.setCloneList(array); -taskpool.execute(task).then((res: Object) => { - console.info('sendable: task res is: ' + res) -}); +let baseInstance1: BaseClass = new BaseClass(); +let array1 = new Array(); +array1.push(baseInstance1); +let task1 = new taskpool.Task(testFunc, array1, 10); +task1.setCloneList(array1); ``` **ArkTS1.2** ```typescript -class BaseClass { - public str: string = 'BaseClass'; -} - -function testFunc(array: Array) { - let baseInstance = array[0]; - console.info('str1 is: ' + baseInstance.str); - return baseInstance.str; -} - - -let baseInstance: BaseClass = new BaseClass(); -let array = new Array(); -array.push(baseInstance); -let task = new taskpool.Task(testFunc, array); -taskpool.execute(task).then((res: NullishType):void => { - console.info('task res is: ' + res) -}); +let baseInstance1: BaseClass = new BaseClass(); +let array1 = new Array(); +array1.push(baseInstance1); +let task1 = new taskpool.Task(testFunc, array1, 10); ``` ## 移除taskpool setTransferList接口 @@ -325,63 +289,21 @@ taskpool.execute(task).then((res: NullishType):void => { **ArkTS1.1** ```typescript -import { taskpool } from '@kit.ArkTS'; - -@Concurrent -function testTransfer(arg1: ArrayBuffer, arg2: ArrayBuffer): number { - console.info('testTransfer arg1 byteLength: ' + arg1.byteLength); - console.info('testTransfer arg2 byteLength: ' + arg2.byteLength); - return 100; -} - let buffer: ArrayBuffer = new ArrayBuffer(8); let view: Uint8Array = new Uint8Array(buffer); let buffer1: ArrayBuffer = new ArrayBuffer(16); let view1: Uint8Array = new Uint8Array(buffer1); - -console.info('testTransfer view byteLength: ' + view.byteLength); -console.info('testTransfer view1 byteLength: ' + view1.byteLength); -// 执行结果为： -// testTransfer view byteLength: 8 -// testTransfer view1 byteLength: 16 - let task: taskpool.Task = new taskpool.Task(testTransfer, view, view1); task.setTransferList([view.buffer, view1.buffer]); -taskpool.execute(task).then((res: Object) => { - console.info('test result: ' + res); -}).catch((e: string) => { - console.error('test catch: ' + e); -}) -console.info('testTransfer view2 byteLength: ' + view.byteLength); -console.info('testTransfer view3 byteLength: ' + view1.byteLength); -// 经过transfer转移之后值为0，执行结果为： -// testTransfer view2 byteLength: 0 -// testTransfer view3 byteLength: 0 ``` **ArkTS1.2** ```typescript -function testTransfer(arg1: Uint8Array, arg2: Uint8Array): number { - console.info('testTransfer arg1 byteLength: ' + arg1.byteLength); - console.info('testTransfer arg2 byteLength: ' + arg2.byteLength); - return 100.0; -} - let buffer: ArrayBuffer = new ArrayBuffer(8); let view: Uint8Array = new Uint8Array(buffer); let buffer1: ArrayBuffer = new ArrayBuffer(16); let view1: Uint8Array = new Uint8Array(buffer1); - let task: taskpool.Task = new taskpool.Task(testTransfer, view, view1); -taskpool.execute(task).then((res: Object) => { - console.info('test result: ' + res); -}).catch((e: Error): void => { - console.error('test catch: ' + e); -}) -// 内存共享，此处可直接访问view,view1的内容，不需要使用setTransferList -// 执行结果为： -// testTransfer arg1 byteLength: 8 -// testTransfer arg2 byteLength: 16 ``` ## 删除ISendable接口 @@ -433,15 +355,335 @@ import { ArkTSUtils } from '@kit.ArkTS' @Sendable function sendableFunc() { - console.info('sendableFunc') + console.info("sendableFunc") } if (ArkTSUtils.isSendable(sendableFunc)) { - console.info('sendableFunc is Sendable'); + console.info("sendableFunc is Sendable"); } else { - console.info('sendableFunc is not Sendable'); + console.info("sendableFunc is not Sendable"); +} +``` + +**ArkTS1.2** +内存共享，不需要判断是否为Sendable对象。 + +## 将Object修改为NullishType。 + +**规则：** arkts-taskpool-execute-generic-type-object-to-nullishtype + +**级别：** error + +ArkTS1.1中taskpool execute 返回值声明为Promise，但实际可以返回值为undefined的Promise。ArkTS1.2中undefined和Object为不同类型，相互之间无法的进行类型转换。 + +**ArkTS1.1** +```typescript +import { taskpool } from '@kit.ArkTS'; + +// 场景一: +@Concurrent +function printLog(str: number): number { + console.log("printLog called: " + str); + return str +} + +async function test1() { + let task = new taskpool.Task(printLog, 10.0); + let a3: Object = await taskpool.execute(task); +} + +// 场景二： +async function test2() { + let task = new taskpool.Task(printLog, 10.0); + let a3 = taskpool.execute(task); + a3.then((res: Object) => { + //do something + }) +} +``` + +**ArkTS1.2** +```typescript +//场景一： +function printLog(str: number): number { + console.log("printLog called: " + str); + return str +} +async function test1() { + let task = new taskpool.Task(printLog, 10.0); + let a3: Object = (await taskpool.execute(task)) as Object; + + //or let a3: NullishType = await taskpool.execute(task); +} + +//场景二： +async function test2() { + let task = new taskpool.Task(printLog, 10.0); + let a3 = taskpool.execute(task); + a3.then((res: NullishType) => { + console.log("d") + }) +} +``` + +## 调用Promise构造器的reject回调和静态方法reject时，使用Error及其子类作为函数入参 + +**规则：** arkts-limited-stdlib-promise-reject-type-error + +**级别：** error + +ArkTS1.2中加强类型限制，由以下spec限制： + +（1）throw 只能抛出Error及其子类。 + +（2）await Promise对象时，如果该Promise被reject，需要抛出其被reject的原因。 + +**ArkTS1.1** +```typescript +let p = new Promise((resolve, reject) => { + reject("error") +}); +Promise.reject("error"); +``` + +**ArkTS1.2** +```typescript +let p = new Promise((resolve, reject) => { + reject(new Error("error")) +}); +Promise.reject(new Error("error")); +``` + +## 调用Promise的then方法和catch方法时，onReject回调的入参类型改为Error + +**规则：** arkts-limited-stdlib-promise-onrejected-type-error + +**级别：** error + +ArkTS1.2中加强类型限制，且类型转换具有运行时语义。为了保证类型安全，spec中限制函数间赋值遵循逆变原则，子类型入参回调无法赋值给父类型入参回调。 + +**ArkTS1.1** +```typescript +import { BusinessError } from "@kit.BasicServicesKit"; + +let p = new Promise((resolve, reject) => { + reject(new BusinessError("error")) +}); +p.then(() => {}, (e: BusinessError) => { + console.log(String(e))}) +p.catch((e: BusinessError) => { console.log(String(e))}) +``` + +**ArkTS1.2** +```typescript +import { BusinessError } from "@ohos.base"; + +let p = new Promise((resolve, reject) => { + reject(new BusinessError()) +}); +p.then(() => { }, (e: Error) => { + let err = e as BusinessError; + console.log(String(err)) +}) +p.catch((e: Error) => { + let err = e as BusinessError; + console.log(String(err)) +}) +``` + +## 删除用户自定义的PromiseFulfilledResult PromiseRejectedResult PromiseSettledResult + +**规则：** arkts-not-support-PromiseSettledResult-customization + +**级别：** error + +ArkTS1.2语言不允许多次定义同名interface。 + +**ArkTS1.1** +```typescript +interface PromiseFulfilledResult { + status: "fulfilled"; + value: T; +} + +interface PromiseRejectedResult { + status: "rejected"; + reason: string; +} + +type PromiseSettledResult = PromiseFulfilledResult | PromiseRejectedResult; +``` + +**ArkTS1.2** +```typescript + +``` + +## 判断后使用as转换成实际类型 + +**规则：** arkts-not-support-PromiseSettledResult-smartcast + +**级别：** error + +arkts1.2中不支持对类的成员变量进行smart cast（smart type差异 (arkts-no-ts-like-smart-type)） + +**ArkTS1.1** +```typescript +Promise.allSettled(asyncOperations) + .then((results:PromiseSettledResult[]) => { + results.forEach((result:PromiseSettledResult) => { + if (result.status === 'fulfilled') { + successMessage += `${result.value} `; + } else { + errorMessage += `${result.reason.message} `; + } + }); + }) +``` + +**ArkTS1.2** +```typescript +Promise.allSettled(asyncOperations) +.then((results:PromiseSettledResult[]) => { +results.forEach((result:PromiseSettledResult) => { + if (result.status === 'fulfilled') { + let result1 = result as PromiseFulfilledResult; + successMessage += `${result1.value} `; + } else { + let result1 = result as PromiseRejectedResult; + errorMessage += `${result1.reason.message} `; + } +}); +}) +``` + +## 声明时直接使用Promise + +**规则：** arkts-no-support-nested-promise + +**级别：** error + +静态类型导致回调执行时运行时类型转换失败，回调无法执行 + +**ArkTS1.1** +```typescript +let p = new Promise>((res, rej) => { res(Promise.resolve(1.0))}); +p.then((res: Promise) => { console.log(res+"")}) +``` + +**ArkTS1.2** +```typescript +let p = new Promise((res, rej) => { res(Promise.resolve(1.0))}); +p.then((res: number) => { console.log(res)}) +``` + +## Task的function属性改名为taskFunction + +**规则：** arkts-change-taskpool-Task-to-taskFunction + +**级别：** error + +function在1.2中为关键字，不能作为类属性(限定关键字(arkts-invalid-identifier)) + +**ArkTS1.1** +```typescript +import { taskpool } from '@kit.ArkTS'; + +function testString(str: string) { + console.log(str); + } +let task: taskpool.Task = new taskpool.Task(testString, "hello"); +let func = task.function; ``` **ArkTS1.2** -内存共享，不需要判断是否为Sendable对象，不再提供isSendable接口。 +```typescript +let func1 = (str: string): string => { + return str; +}; +let task: taskpool.Task = new taskpool.Task(func1, "hello"); +let func = task.taskFunction; +``` + +## 直接使用taskpool.Task，不使用GenericsTask. + +**规则：** arkts-not-supprot-genericstask + +**级别：** error + +（1）arkts1.2中不支持以泛型数组的形式对回调参数类型进行校验； +（2）arkts1.2不支持将非可变参数类型回调赋值给可变参数函数 + +**ArkTS1.1** +```typescript +@Concurrent +function testWithThreeParams(a: number, b: string, c: number): string { + return b; +} +let task1: taskpool.Task = new taskpool.GenericsTask<[number, string, number], string>(testWithThreeParams, 100, "test", 100); +``` + +**ArkTS1.2** +```typescript +function testWithThreeParams(a: number, b: string, c: number): string { + return b; +} +let task1: taskpool.Task = new taskpool.Task<[number, string, number], string>(testWithThreeParams, 100, "test", 100); +``` + +## 不在全局初始化阶段调用async函数 + +**规则：** arkts-not-support-global-async-call + +**级别：** error + +根据ArkTS1.2 SPEC，全局初始化阶段不可以调用异步函数，原因是会难以推导初始化结果 + +**ArkTS1.1** +```typescript +async function asynctest() {} +asynctest(); +function f1() { asynctest(); } +f1(); +``` + +**ArkTS1.2** +```typescript +async function asynctest() {} +function f1() { asynctest(); } +function main() { + asynctest(); + f1(); +} +``` + +## 使用resolve(undefined) + +**规则：** arkts-promise-with-void-type-need-undefined-as-resolve-arg + +**级别：** error + +1.2中void不能作为变量类型声明；作为泛型时，在类实例化时会自动转换为undefined +**ArkTS1.1** +```typescript +let p1 = new Promise((resolve, reject) => { + resolve(); +}) +let p2 = new Promise((resolve, reject) => { + setTimeout(resolve, 10); +}) +``` + +**ArkTS1.2** +```typescript +let p1 = new Promise((resolve, reject) => { + resolve(); +}) +let p2 = new Promise((resolve, reject) => { + setTimeout(() => {resolve(undefined)}, 10); +}) +``` + + + -- Gitee