HarmonyOS Next Concurrency Basics: Coroutines and Structured Concurrency

In HarmonyOS Next development, concurrent programming is a key technology to improve application performance and responsiveness.Coroutines and structured concurrency are important concepts in modern concurrent programming, providing developers with more efficient and safer concurrency control methods.As a technical expert with rich practical experience in this field, I will analyze the core points of coroutines and structured concurrency in depth, including lightweight threading characteristics, cancel propagation mechanisms, and the use of debugging tools.

Chapter 1: Lightweight Threading

Coroutines are essentially lightweight threads, and in HarmonyOS Next, they have significant advantages over traditional threads.By creating a concurrent memory footprint test of 100,000 coroutines, we can intuitively see the efficiency of coroutines in resource utilization.

import std.concurrent.*

func lightweightThreadTest() {
    let startTime = getCurrentTime()
    let coroutines = (0..100000).map { _ in
        async {
// Simulate some simple tasks
            let result = 1 + 2
            return result
        }
    }
    let results = awaitAll(coroutines)
    let endTime = getCurrentTime()
    let elapsedTime = endTime - startTime
println("Concurrent execution time taken by 100,000 coroutines: \(elapsedTime) ms")
println("Memory usage can be viewed through the system monitoring tool")
}

In the above code, 100,000 coroutines are created using the async keyword, each coroutine performs a simple addition task.awaitAll is used to wait for all coroutines to complete execution and get the results.Judging from the actual test results, the time-consuming time for concurrent execution of 100,000 coroutines is relatively short, and in terms of memory usage, coroutines do not occupy a large amount of system resources like traditional threads because of their lightweight properties.This enables coroutines to achieve efficient parallel processing of tasks with limited resources when dealing with high concurrency scenarios.

Chapter 2: Cancel the spread

Unpropagation is an important mechanism in structured concurrency, which ensures the correct binding of life cycles between parent-child tasks.For example, in a complex task, the parent task may initiate multiple child tasks, and when the parent task is cancelled, all relevant child tasks should also be cancelled to avoid resource waste and inconsistent states.

import std.concurrent.*

func parentTask() async {
    let childTask1 = async {
        for (i in 0..1000) {
// Simulate some work
            print(i)
            if cancellation.isCancelled {
                break
            }
        }
    }
    let childTask2 = async {
        for (i in 0..1000) {
// Simulate some work
            print(i)
            if cancellation.isCancelled {
                break
            }
        }
    }
    try {
        await childTask1
        await childTask2
    } catch {
// Handle cancel exception
println("Task cancelled")
    }
}

func main() async {
    let task = async {
        await parentTask()
    }
// Cancel the task after a period of simulation
    await delay(100)
    task.cancel()
    try {
        await task
    } catch {
// Handle cancel exception
println("The main task catches cancel exception")
    }
}

In this code, parentTask initiates two subtasks childTask1 and childTask2.Inside the subtask, check cancellation.isCancelled to determine whether it is cancelled.When the task in the main function is cancelled, the parentTask and its subtasks childTask1 and childTask2 will receive the cancel signal and process it accordingly, thus ensuring the consistency of the task and the effective management of resources.

Chapter 3: Debugging Tools

The visual coroutine scheduler observation tool is a powerful assistant for debugging concurrent programs.In HarmonyOS Next development, with the help of these tools, developers can intuitively observe the scheduling of coroutines, including the creation, execution, pause and recovery of coroutines.For example, by adding some debugging marks to your code, you can clearly see the execution trajectory and timeline of different coroutines in the visualization tool.

import std.concurrent.*
import std.debug.*

func debugCoroutine() async {
debugLog("Coprocess starts execution")
    let result = await async {
debugLog("Subcord execution starts")
        let subResult = 1 + 2
debugLog("Subcord execution ends")
        return subResult
    }
debugLog("Coecho execution ends, result: \(result)")
}

func main() async {
    await debugCoroutine()
}

In the above code, use debugLog to record key information during coroutine execution.Through the visual coroutine scheduler observation tool, these debugging information are presented visually, and developers can more conveniently discover problems in concurrent programs, such as coroutine deadlocks, unreasonable scheduling, etc., thereby making targeted optimization and improvements.

Mastering the core technologies of coroutines and structured concurrency, including efficient utilization of lightweight threads, correct implementation of cancelled propagation mechanisms, and proficient use of debugging tools, can help developers build more stable and efficient concurrent applications in HarmonyOS Next development.Whether it is handling highly concurrent network requests or complex backend tasks, these technologies provide strong support for developers.