jspahrsummers / safedispatch

A Cocoa framework to make Grand Central Dispatch safer (deprecated).

The SafeDispatch framework is a Cocoa wrapper for Grand Central Dispatch that adds important safety features. Not all of GCD is included – the main focus is on improving dispatch queues and groups.

This framework is no longer supported, and is hard to use correctly. If you're looking for a better way to do concurrency, check out ReactiveCocoa instead.

Features

Besides an easy-to-use Objective-C API, this framework adds:

• Recursive synchronous dispatch. dispatch_sync() deadlocks when targeting the current queue – SDQueue does not.
• Conditionally asynchronous or synchronous dispatch. Blocks can be run synchronously if targeting the current queue, or asynchronously if targeting another.
• Exception-safe synchronous dispatch, to support throwing exceptions from synchronous blocks and propagating them to callers.
• Synchronization across multiple queues, based on a deterministic total ordering of the queues (to prevent deadlocks).
• Prologue and epilogue blocks, to perform work before or after each block added to a queue.
• Better detection of the current queue. SafeDispatch can identify whether code is executing on a given queue even if that queue is many layers up the call stack. (This is especially important for recursive and conditional dispatch.)

License

Copyright (c) 2012 Justin Spahr-Summers

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

safedispatch's Issues

Add an SDQueue key/value stack

As noted in #1, dispatch_get_specific() can't really be used with SDQueue because of the possibility of reentrant dispatch. It'd be nice to have a parallel feature in SafeDispatch that honors the emulated stack (instead of the real one).

"Safe" synchronous operations can deadlock in the face of target queues

Try adding this test to SDQueueTests.m:

- (void)testTargetedQueueDeadlock
{
    dispatch_queue_t firstQueueT = dispatch_queue_create("1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t secondQueueT = dispatch_queue_create("2", DISPATCH_QUEUE_SERIAL);

    dispatch_set_target_queue(firstQueueT, secondQueueT);

    SDQueue *firstQueue = [SDQueue queueWithGCDQueue:firstQueueT concurrent:NO private:YES];
    SDQueue *secondQueue = [SDQueue queueWithGCDQueue:secondQueueT concurrent:NO private:YES];

    __block BOOL finished = NO;

    [firstQueue runSynchronously:^{
        [secondQueue runSynchronously:^{
            [firstQueue runSynchronously:^{
                finished = YES;
            }];
        }];
    }];

    STAssertTrue(finished, @"");
}

I'm pretty sure the usage of dispatch_get_current_queue() throughout SDQueue.m isn't safe in the face of target queue usage.

This looks like a pretty contrived example, but it could get much worse much faster. I think it means that the SDQueue constructors which take a dispatch_queue_t argument are only safe if you made the queue yourself, and it never "escapes" your control.

If I provide an API like the following, and the client gives me a dispatch_queue_t which targets another, and then makes two of these, then I can't use any of the safe SDQueue operations:

@interface TestAPI : NSObject
- (instancetype)initWithQueue:(dispatch_queue_t)queue;
- (void)doThingInConcertWithOtherGuy:(TestAPI *)otherGuy;
@end

It might be worth just removing the constructors which take a dispatch_queue_t as argument. But that'd kind of unfortunate, since targeting semantics are actually useful. Maybe you could remove those constructors, then provide targeting semantics yourself on SDQueue which could then attempt to avoid cycles. But I'm not sure you could avoid cycles in a thread-safe way, since the target queues involved could change out from under you on various queues while you're traversing the graph. You'd have to be very careful about the guarantees made about the timing of your setTargetQueue: method: I doubt you could make the same guarantees that GCD makes about when the new target queue's applied.