harmony 鸿蒙I/O Intensive Task Development

2023-10-30
浏览 (413)

I/O Intensive Task Development

Asynchronous concurrency can solve the problem of a single blocking I/O operation. In the case of I/O intensive tasks, the execution of other tasks in the thread is still blocked. To resolve this issue, multithread concurrency is introduced.

The performance focus of I/O intensive tasks is not the CPU processing capability, but the speed and efficiency of I/O operations, since such a task usually requires frequent operations such as disk read/write and network communication. The following uses frequent read/write operations on a system file to simulate concurrency processing of I/O intensive tasks.

Define a concurrency function that internally calls I/O capabilities intensively.

// a.ts
import fs from '@ohos.file.fs';


// Define a concurrency function that internally calls I/O capabilities intensively.
// Implement file writing.
export async function write(data: string, filePath: string): Promise<void> {
  let file: fs.File = await fs.open(filePath, fs.OpenMode.READ_WRITE);
  await fs.write(file.fd, data);
  fs.close(file);
}

import { write } from './a'
import { BusinessError } from '@ohos.base';


@Concurrent
async function concurrentTest(fileList: string[]): Promise<boolean> {
  // Write the file cyclically.
  for (let i: number = 0; i < fileList.length; i++) {
    write('Hello World!', fileList[i]).then(() => {
      console.info(`Succeeded in writing the file. FileList: ${fileList[i]}`);
    }).catch((err: BusinessError) => {
      console.error(`Failed to write the file. Code is ${err.code}, message is ${err.message}`)
      return false;
    })
  }
  return true;
}

Use TaskPool to execute the concurrency function that contains the intensive I/O operations. Specifically, call execute() to execute the tasks and process the scheduling result in a callback. For details about how to obtain filePath1 and filePath2 in the example, see Obtaining Application File Paths.

import taskpool from '@ohos.taskpool';


let filePath1: string = "path1"; // Application file path.
let filePath2: string = "path2";


// Use TaskPool to execute the concurrency function that contains the intensive I/O operations.
// In the case of a large array, the distribution of I/O intensive tasks also preempts the main thread. Therefore, multiple threads are required.
taskpool.execute(concurrentTest, [filePath1, filePath2]).then(() => {
  // Process the scheduling result.
})