Non Blocking Channel Operations in Objective-C

In Objective-C, we don’t have a direct equivalent to Go’s channels and select statements. However, we can use Grand Central Dispatch (GCD) to achieve similar non-blocking operations. Here’s an example that demonstrates non-blocking operations using GCD:

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        dispatch_queue_t queue = dispatch_queue_create("com.example.queue", DISPATCH_QUEUE_CONCURRENT);
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        
        // Simulating a non-blocking receive
        dispatch_async(queue, ^{
            long result = dispatch_semaphore_wait(semaphore, DISPATCH_TIME_NOW);
            if (result == 0) {
                NSLog(@"received message");
            } else {
                NSLog(@"no message received");
            }
        });
        
        // Simulating a non-blocking send
        NSString *msg = @"hi";
        dispatch_async(queue, ^{
            long result = dispatch_semaphore_signal(semaphore);
            if (result == 0) {
                NSLog(@"sent message: %@", msg);
            } else {
                NSLog(@"no message sent");
            }
        });
        
        // Simulating a multi-way non-blocking select
        dispatch_async(queue, ^{
            long result = dispatch_semaphore_wait(semaphore, DISPATCH_TIME_NOW);
            if (result == 0) {
                NSLog(@"received message");
            } else {
                long signalResult = dispatch_semaphore_wait(semaphore, DISPATCH_TIME_NOW);
                if (signalResult == 0) {
                    NSLog(@"received signal");
                } else {
                    NSLog(@"no activity");
                }
            }
        });
        
        // Allow time for async operations to complete
        [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];
    }
    return 0;
}

This Objective-C code demonstrates concepts similar to non-blocking channel operations:

We create a concurrent dispatch queue and a semaphore to simulate channel-like behavior.
The first dispatch_async block simulates a non-blocking receive. It attempts to wait on the semaphore with DISPATCH_TIME_NOW, which returns immediately if the semaphore can’t be decremented.
The second dispatch_async block simulates a non-blocking send. It attempts to signal the semaphore, which increments it if possible.
The third dispatch_async block simulates a multi-way non-blocking select. It first tries to receive a message, then a signal, and if both fail, it reports no activity.
We use NSRunLoop to allow time for the asynchronous operations to complete before the program exits.

To run this program, save it as NonBlockingOperations.m and compile it with:

$ clang -framework Foundation NonBlockingOperations.m -o NonBlockingOperations

Then run it with:

$ ./NonBlockingOperations

The output will vary depending on the exact timing of the operations, but it will demonstrate the non-blocking nature of the operations.

While this isn’t a direct translation of the original code, it demonstrates similar concepts of non-blocking operations in Objective-C using GCD, which is more idiomatic for the language.

Timeouts in Objective-C

Closing Channels in Objective-C

Learn X By Example

Title here

Non Blocking Channel Operations in Objective-C