alibaba/coobjc

Features

• Asynchronous Programming - Enables non-blocking workflows in Objective-C and Swift through the implementation of coroutines and await methods.
• Asynchronous Message Passings - Provides an actor model where isolated entities exchange data exclusively through asynchronous message passing.
• Custom Data Channels - Implements communication primitives for exchanging data between concurrent tasks using buffered and unbuffered channels.
• Asynchronous Flow Coordination - Provides patterns for managing the synchronization and resolution of concurrent asynchronous operations.
• Coroutine Launchers - Enables initiating the execution of asynchronous coroutine blocks on specific target queues.
• Lazy Sequences - Provides lazy sequence generators that produce values on demand via yield to handle large data sets efficiently.
• Coroutine Libraries - Provides a comprehensive coroutine library for managing cooperative multitasking and lightweight threads in Objective-C and Swift.
• Block-Based Coroutines - Transforms asynchronous code blocks into state machines to enable non-blocking suspension and resumption.
• Native API Wrappers - Wraps synchronous system APIs into non-blocking operations to maintain user interface responsiveness.
• Non-Blocking API Wrappers - Converts synchronous system calls into suspendable operations compatible with a coroutine runtime.
• Actor-Based Concurrency - Uses isolated, message-passing actors to manage state and execution without data races.
• Asynchronous Task Managers - Offers tools for coordinating complex execution flows using await methods and channels to synchronize concurrent tasks.
• Coroutine Task Schedulers - Manages a queue of lightweight coroutines and distributes them across worker pools for efficiency.
• Lock-Free State Management - Utilizes an actor model to manage shared state and prevent data races in Apple ecosystem applications.
• Coroutine Communication Channels - Provides communication channels for exchanging signals and data between concurrent coroutines.
• CSP Communication Channels - Provides synchronization primitives based on communicating sequential processes for data exchange between concurrent tasks.
• Lazy Sequence Processing - Implements a lazy sequence generator to produce values on demand, reducing memory allocation for large data sets.
• Coroutine Result Awaiting - Allows suspending a coroutine until a promise or channel resolves to return a value.
• Sequential Task Execution - Executes a series of asynchronous computations in a strict linear order to prevent nested callbacks.
• Lazy Data Scanning - Defers data processing until requested to ensure the system only handles data when the consumer is ready.
• Asynchronous Sequence Generators - Implements generators that produce sequences of values where each element is fetched via an async operation.
• Coroutine Suspension Controls - Enables suspending tasks and restoring them later from the last known state using custom calling stacks.
• Custom Execution Stacks - Implements custom call-stack management to restore task state after await calls.
• Lazy Evaluation - Implements lazy evaluation to produce data sequences one item at a time and reduce memory overhead.
• Coroutine Termination - Implements a mechanism to cooperatively stop executing coroutines and perform necessary cleanup.
• Non-blocking IO Implementations - Provides non-blocking implementations for file system and networking operations to maintain user interface responsiveness.
• Asynchronous File I/O - Provides non-blocking interfaces for reading and writing files without stalling the execution thread.

Star history