Effortless Concurrency: Cangjie's Concurrency Programming Model in HarmonyOS 5

In scenarios such as smart terminals, the Internet of Things (IoT), and edge computing, concurrency capabilities have become a critical element in modern application development. Especially in the new HarmonyOS 5 ecosystem, which emphasizes multi-device collaboration and real-time responsiveness, how to write secure and scalable concurrent programs in a simple and efficient manner has become a major challenge for developers.

Thankfully, the Cangjie language has created an elegant and efficient model for concurrency programming, significantly reducing development complexity. As an engineer who has long participated in the HarmonyOS 5 project, I will now combine practical examples to take you deep into the power of Cangjie's concurrency model.

Lightweight User-Mode Threads: The Foundation of Efficient Concurrency

The Cangjie language abandons the heavyweight design of traditional system threads and adopts lightweight user-mode threads, which have the following characteristics:

• Extremely Lightweight: Each thread requires minimal resources, far less than system threads.
• User-Mode Management: Thread creation, scheduling, and destruction are all controlled by the Cangjie runtime.
• Shared Memory Space: Threads can share data, facilitating communication.
• Compatibility with Traditional APIs: Used in the same way as system threads, making it easy to learn.

Why Choose User-Mode Threads?

Traditional system threads (such as Pthreads) have many issues:

• High overhead for creation and destruction.
• High context switching costs during scheduling.
• Limited number of threads, typically only thousands can be created.

Cangjie's user-mode threads offer significant advantages:

• Creation requires only tens of bytes of memory and microseconds of time.
• Easily manage tens of thousands of threads on a single machine.
• Scheduling is completed at the language layer, fast and controllable.

Example: Starting Multiple Cangjie Threads

import runtime.thread

main() {
    for (let i in 0..10) {
        thread.start {
            println("Hello from thread ${i}")
        }
    }
}

Output (similar to):

Hello from thread 0  
Hello from thread 1  
Hello from thread 2  
...

• thread.start is used to start a new lightweight thread.
• The anonymous code block is the thread's execution body.
• The coding experience is similar to a regular function call, simple and convenient.

Concurrent Object Library: Thread Safety Has Never Been Easier

In traditional concurrent programming, data races and deadlocks are tough problems. Cangjie greatly reduces the burden on developers for handling concurrency through its built-in Concurrent Object Library, with the following mechanisms:

• Concurrent Objects: Internal methods automatically implement thread safety, eliminating the need for manual locking by developers.
• Lock-Free/Fine-Grained Locking: Some core libraries use lock-free designs to pursue extreme performance.
• Consistent API Experience: The syntax for concurrent and serial calls is exactly the same.

Example: Using Thread-Safe Concurrent Objects

mut class Counter {
    private var count = 0

    public func inc(): Unit {
        count += 1
    }

    public func get(): Int {
        return count
    }
}

main() {
    let counter = concurrent(Counter())

    for (let i in 0..1000) {
        thread.start {
            counter.inc()
        }
    }

    sleep(1 * Duration.Second)
    println("Final count: ${counter.get()}")
}

• concurrent(obj) converts ordinary objects into thread-safe objects.
• No manual locking is required when calling inc() concurrently across multiple threads.
• sleep ensures all threads complete execution.

Practical Experience: In the past, writing concurrent logic required careful lock management. Now, with the Concurrent Object Library, concurrent operations can be performed almost effortlessly, significantly improving development speed and code correctness.

Lock-Free and Fine-Grained Locking: Ensuring Extreme Performance

Although default concurrent objects meet most scenarios, in performance-critical scenarios (such as high-frequency trading or real-time sensor processing), the overhead of locks cannot be ignored. To address this, Cangjie's concurrency library uses lock-free or fine-grained locking techniques for some core structures (such as lock-free queues and CAS variables), with the following advantages:

• Lock-Free: Avoids thread blocking and improves system throughput.
• Fine-Grained Locking: Reduces lock contention and enhances concurrency.
• Spinlock: Suitable for scenarios with high-frequency operations over short periods.

Practical Example (From Cangjie's Standard Library)

let queue = concurrent.Queue()

thread.start {
    for (let i in 0..100) {
        queue.enqueue(i)
    }
}

thread.start {
    for (let i in 0..100) {
        if (queue.dequeue() != null) {
            println("Got item")
        }
    }
}

• The Queue is internally implemented with a lock-free algorithm for excellent performance.
• Suitable for high-concurrency producer-consumer scenarios.

Summary Table: Overview of Cangjie's Concurrency Features

Feature	Description	Practical Significance
User-Mode Threads	Lightweight, efficient, supports massive threads	Enables fast response and high concurrency
Concurrent Object Library	Automatic thread-safe encapsulation	Simplifies development and reduces code vulnerabilities
Lock-Free/Fine-Grained Lock Optimization	Achieves high-performance concurrency	Meets extreme performance requirements

Conclusion

Cangjie achieves an excellent balance in concurrency design:

• Simplicity and Ease of Use: Novices can easily write correct concurrent programs.
• Extreme Performance: Advanced users can perform deep optimizations to fully leverage hardware capabilities.
• Security and Reliability: Effectively avoids most common concurrency issues.

Cangjie is both concurrency-friendly and highly controllable. When developing multi-device collaborative applications for HarmonyOS 5, this efficient concurrency capability is crucial. As the ecosystem continues to grow, we believe Cangjie's concurrency programming capabilities will play a key role in more complex projects.