Memory and Resource Management Advanced Techniques in HarmonyOS 5 Cangjie Language: GC and Try-With-Resources

This article aims to deeply explore the technical details of Huawei's HarmonyOS 5 system, summarized based on actual development practices. It serves primarily as a carrier for technical sharing and communication. Errors and omissions are inevitable, and colleagues are welcome to provide valuable feedback and questions for mutual improvement. This is original content, and any form of reprinting must credit the source and original author.

1. Tracing GC: The Core Technology for Efficient Memory Management

Memory leaks are like accumulated garbage in a room—if left unattended, they eventually cause space congestion. Cangjie's Tracing GC (Tracing Garbage Collection) technology is akin to a robotic vacuum with lidar, precisely identifying and cleaning up "garbage" in memory.

1.1 Reference Counting vs. Tracing GC

Let’s first examine a classic circular reference scenario:

class Node {  
    var next: ?Node  
}  
let nodeA = Node()  
let nodeB = Node()  
nodeA.next = nodeB  
nodeB.next = nodeA  // Formation of circular reference!

With Reference Counting (RC), these two objects would never be released. Cangjie’s Tracing GC correctly recovers them through reachability analysis, with the following principles:

Scan object reference chains starting from GC Roots (global variables, stack variables, etc.).
Mark all reachable objects as "alive."
Collect unmarked objects.

In HarmonyOS 5’s graphics rendering engine, Tracing GC improved memory usage efficiency by 40%.

1.2 Secrets of GC Performance Optimization

Cangjie’s GC is not a simple "stop-the-world" mechanism but employs the three-color marking algorithm:

Color	Meaning	Handling Method
White	Not visited	To be collected
Gray	Visited but child nodes not processed	To be further scanned
Black	Fully processed	Retained

Combined with a generational collection strategy (young/old generations), tests on HarmonyNext smartwatches show GC pause times can be controlled within 3ms.

2. Value Types: The Foundation of Concurrency Safety

In HarmonyOS’s multi-device ecosystem, value types act like "deep-copy delivery boxes," ensuring no unintended shared modifications during data transmission.

2.1 Practical Use of Value Semantics

struct DeviceInfo {  
    var id: String  
    var status: Int  
}  
let deviceA = DeviceInfo(id: "D001", status: 1)  
var deviceB = deviceA  // Value copy occurs!  
deviceB.status = 2  
print(deviceA.status)  // Outputs 1 (unaffected)

Contrast with the risky behavior of reference types:

class DeviceInfo { /*...*/ }  
let deviceA = DeviceInfo()  
let deviceB = deviceA  // Reference copy!  
deviceB.status = 2    // deviceA is also modified

2.2 Distributed Scenario Application

In HarmonyNext’s cross-device file synchronization feature, we use value types to transmit metadata:

Device A wraps file information into a struct FileMeta.
Sends it to Device B via the distributed bus.
Modifications to Device B’s copy do not affect the original data.

Tests show an 85% reduction in data race issues compared to traditional schemes.

3. Try-With-Resources: The Magic of Automatic Resource Recycling

Forgetting to close resources is like leaving a toilet unflushed—it will cause problems eventually. Cangjie’s try-with-resources syntax acts like an automatic sensor flushing mechanism.

3.1 Safe File Operation Example

class FileHandle: Resource {  
    func isClosed() -> Bool { /*...*/ }  
    func close() { /*...*/ }  
}  
try (input = FileHandle("a.txt"),  
     output = FileHandle("b.txt")) {  
    while let line = input.readLine() {  
        output.writeLine(line.uppercased())  
    }  
}  // Automatically closes resources on normal completion or exception

3.2 Comparison with Traditional Writing

Traditional approaches require triple-nested try-catch:

FileInputStream in = null;  
try {  
    in = new FileInputStream("a.txt");  
    //...  
} finally {  
    if (in != null) in.close();  // Must also handle close exceptions  
}