同步任务开发指导

2024-02-16 13:46 更新

同步任务是指在多个线程之间协调执行的任务,其目的是确保多个任务按照一定的顺序和规则执行,例如使用锁来防止数据竞争。

同步任务的实现需要考虑多个线程之间的协作和同步,以确保数据的正确性和程序的正确执行。

由于TaskPool偏向于单个独立的任务,因此当各个同步任务之间相对独立时推荐使用TaskPool,例如一系列导入的静态方法,或者单例实现的方法。如果同步任务之间有关联性,则需要使用Worker,例如无法单例创建的类对象实现的方法。

使用TaskPool处理同步任务

当调度独立的同步任务,或者一系列同步任务为静态方法实现,或者可以通过单例构造唯一的句柄或类对象,可在不同任务池之间使用时,推荐使用TaskPool。

  1. 定义并发函数,内部调用同步方法。

  2. 创建任务,并通过TaskPool执行,再对异步结果进行操作。创建Task,通过execute()执行同步任务。

模拟一个包含同步调用的单实例类。

  1. // Handle.ts 代码
  2. export default class Handle {
  3. static getInstance() {
  4. // 返回单例对象
  5. }
  6. static syncGet() {
  7. // 同步Get方法
  8. return;
  9. }
  10. static syncSet(num: number) {
  11. // 同步Set方法
  12. return;
  13. }
  14. }

业务使用TaskPool调用相关同步方法的代码。

  1. // Index.ets代码
  2. import taskpool from '@ohos.taskpool';
  3. import Handle from './Handle'; // 返回静态句柄
  4. // 步骤1: 定义并发函数,内部调用同步方法
  5. @Concurrent
  6. function func(num: number) {
  7. // 调用静态类对象中实现的同步等待调用
  8. Handle.syncSet(num);
  9. // 或者调用单例对象中实现的同步等待调用
  10. Handle.getInstance().syncGet();
  11. return true;
  12. }
  13. // 步骤2: 创建任务并执行
  14. async function asyncGet() {
  15. // 创建task并传入函数func
  16. let task = new taskpool.Task(func, 1);
  17. // 执行task任务,获取结果res
  18. let res = await taskpool.execute(task);
  19. // 对同步逻辑后的结果进行操作
  20. console.info(String(res));
  21. }
  22. @Entry
  23. @Component
  24. struct Index {
  25. @State message: string = 'Hello World';
  26. build() {
  27. Row() {
  28. Column() {
  29. Text(this.message)
  30. .fontSize(50)
  31. .fontWeight(FontWeight.Bold)
  32. .onClick(() => {
  33. // 步骤3: 执行并发操作
  34. asyncGet();
  35. })
  36. }
  37. .width('100%')
  38. .height('100%')
  39. }
  40. }
  41. }

使用Worker处理关联的同步任务

当一系列同步任务需要使用同一个句柄调度,或者需要依赖某个类对象调度,无法在不同任务池之间共享时,需要使用Worker。

  1. 在主线程中创建Worker对象,同时接收Worker线程发送回来的消息。

    1. import worker from '@ohos.worker';
    2. @Entry
    3. @Component
    4. struct Index {
    5. @State message: string = 'Hello World';
    6. build() {
    7. Row() {
    8. Column() {
    9. Text(this.message)
    10. .fontSize(50)
    11. .fontWeight(FontWeight.Bold)
    12. .onClick(() => {
    13. let w = new worker.ThreadWorker('entry/ets/workers/MyWorker.ts');
    14. w.onmessage = function (d) {
    15. // 接收Worker子线程的结果
    16. }
    17. w.onerror = function (d) {
    18. // 接收Worker子线程的错误信息
    19. }
    20. // 向Worker子线程发送Set消息
    21. w.postMessage({'type': 0, 'data': 'data'})
    22. // 向Worker子线程发送Get消息
    23. w.postMessage({'type': 1})
    24. // ...
    25. // 根据实际业务,选择时机以销毁线程
    26. w.terminate()
    27. })
    28. }
    29. .width('100%')
    30. }
    31. .height('100%')
    32. }
    33. }
  2. 在Worker线程中绑定Worker对象,同时处理同步任务逻辑。

    1. // handle.ts代码
    2. export default class Handle {
    3. syncGet() {
    4. return;
    5. }
    6. syncSet(num: number) {
    7. return;
    8. }
    9. }
    10. // MyWorker.ts代码
    11. import worker, { ThreadWorkerGlobalScope, MessageEvents } from '@ohos.worker';
    12. import Handle from './handle.ts' // 返回句柄
    13. var workerPort : ThreadWorkerGlobalScope = worker.workerPort;
    14. // 无法传输的句柄,所有操作依赖此句柄
    15. var handler = new Handle()
    16. // Worker线程的onmessage逻辑
    17. workerPort.onmessage = function(e : MessageEvents) {
    18. switch (e.data.type) {
    19. case 0:
    20. handler.syncSet(e.data.data);
    21. workerPort.postMessage('success set');
    22. case 1:
    23. handler.syncGet();
    24. workerPort.postMessage('success get');
    25. }
    26. }
以上内容是否对您有帮助:
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号