鸿蒙Arkts如何使用多线程并发-Worker

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import worker, { ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@ohos.worker';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

/**
 * Defines the event handler to be called when the worker thread receives a message sent by the host thread.
 * The event handler is executed in the worker thread.
 *
 * @param e message data
 */
workerPort.onmessage = function (e: MessageEvents) {
  let oldArr = e.data;
  let newArr = strSort(oldArr);
  workerPort.postMessage(newArr);

}

/**
 * Defines the event handler to be called when the worker receives a message that cannot be deserialized.
 * The event handler is executed in the worker thread.
 *
 * @param e message data
 */
workerPort.onmessageerror = function (e: MessageEvents) {
  console.log("onmessageerror worker::error = " + e.data);
}

/**
 * Defines the event handler to be called when an exception occurs during worker execution.
 * The event handler is executed in the worker thread.
 *
 * @param e error message
 */
workerPort.onerror = function (e: ErrorEvent) {
  console.log("onerror worker::error ");
}

function strSort(inPutArr): string {
  let newArr = inPutArr.sort();
  for (let index = 0; index < newArr.length; index++) {
    const element = newArr[index];
    console.info(`ConcurrencyPage newArr js ${element}`)
  }
  return newArr;
}

1
2
3
4

	myWorker: worker.ThreadWorker = new worker.ThreadWorker("entry/ets/workers/MyWorker.ts");
	jsWorkerInPutArr: string[] = [];
	@State jsWorkerOutPutStr: string = ''
	@State jsWorkerInPutStr: string = 'I am,go home,go,thank you,help me,wellcome,get out,I need your help,bye bye,good night'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

	async executeWorkerFunc(inPutArr: string[]): Promise<void> {
		if (!this.jsWorkerInPutStr.length) {
			this.jsWorkerOutPutStr = "No input for the string to be sorted.\n";
			return;
		}

		for (let index = 0; index < inPutArr.length; index++) {
			console.log(`${this.TAG}, jsWorkerInPutStr:${inPutArr[index]}`)
		}

		this.myWorker.postMessage(inPutArr);
		let strFlag = false;
		let outPutStr = '';
		this.myWorker.onmessage = (e) => {
			outPutStr = e.data.toString();
			console.log(`${this.TAG}, onmessage outPutStr:${outPutStr}`)
			strFlag = true;
		}
		while (!strFlag) {
			await this.promiseCase();
		}
		this.jsWorkerOutPutStr = outPutStr;
	}

	async promiseCase(): Promise<Object | void> {
		let p: Promise<Object | void> = new Promise<Object>((resolve: Function, reject: Function) => {
			setTimeout(() => {
				resolve(1)
			}, 100)
		}).then(undefined, () => {
		})
		return p;
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    Text('Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与主线程分离，在后台线程中运行一个脚本操作耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞主线程的运行')
                .width('80%')
    Text('Worker创建后需要手动管理生命周期，且最多同时运行的Worker子线程数量为8个，详情请参见生命周期注意事项。\nAbility类型的Module支持使用Worker，Library类型的Module不支持使用Worker。\n创建Worker不支持使用其他Module的Worker.ts文件，即不支持跨模块调用Worker。\n由于不同线程中上下文对象是不同的，因此Worker线程只能使用线程安全的库，例如UI相关的非线程安全库不能使用。\n序列化传输的数据量大小限制为16MB。\n使用Worker模块时，需要在主线程中注册onerror接口，否则当worker线程出现异常时会发生jscrash问题。')
        .width('80%')

    Text(this.jsWorkerInPutStr)
        .width('80%').fontColor(Color.Green)

    Text(`Worker 字符串排序后:${this.jsWorkerOutPutStr}`)
        .width('80%')

    Button('Worker分割字符串')
        .width('80%')
        .onClick(() => {
            this.jsWorkerInPutArr = this.jsWorkerInPutStr.trim().split(',');
            this.jsWorkerOutPutStr = '';
            this.executeWorkerFunc(this.jsWorkerInPutArr);
        })