Gentle Introduction to Grand Central Dispatch Better to Remain Silent and Be Thought a Fool than to Speak and Remove All Doubt 

Blocks • Topic unto themselves • Minimal info here • *async calls copy block • Blocks are true ObjC objects • All ObjC objects are retained when block is copied 

Queues • Just a data structure (FIFO) • List of Blocks • enqueue • Atomic, lock-free • dequeue • Automatically handled by the “system” 

Serial Queue enqueue dequeue 

Concurrent Queue enqueue dequeue 

Automatic Thread Management • Queues are not Threads! • Automatically creates threads as needed • Manages threads for concurrent queues based on processor utilization • Serial queues use overcommit queues • Can overwhelm system with blocks that pend for any reason 

Global Queues • Concurrent • Based on Priority #define DISPATCH_QUEUE_PRIORITY_HIGH 2 #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 #define DISPATCH_QUEUE_PRIORITY_LOW (-2) #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN • dispatch_get_global_queue dispatch_queue_t dispatch_get_global_queue( long priority, unsigned long flags); dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

dispatch_queue_t • Obtain a global queue or main queue dispatch_queue_t dispatch_get_global_queue( long priority, unsigned long flags); dispatch_queue_t dispatch_get_main_queue(void); • Create a private queue dispatch_queue_t dispatch_queue_create( const char *label dispatch_queue_attr_t attr); • All private queues target a global queue • dispatch_retain/dispatch_release 

dispatch_async • Puts block on queue, returns immediately • Block is copied to heap • Beware retain cycles • Execution is started in FIFO • Concurrent queues may not finish FIFO 

dispatch_async • Must manually retain dispatch objects - (void)doSomethingThenInvokeBlock:(void(^)(void))block onQueue:(dispatch_queue_t)queue { dispatch_retain(queue); dispatch_async(dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // Do Something... dispatch_async(queue, block); dispatch_release(queue); }); } • Dispatch objects are ObjC objects in iOS 6 and Mountain Lion 

dispatch_async • Handle all up to iOS6 / Mountain Lion #include #if OS_OBJECT_USE_OBJC static inline void wjhDispatchRetain(dispatch_queue_t queue) { } static inline void wjhDispatchRelease(dispatch_queue_t queue) { } #else static inline void wjhDispatchRetain(dispatch_queue_t queue) { dispatch_retain(queue); } static inline void wjhDispatchRelease(dispatch_queue_t queue) { dispatch_release(queue); } #endif 

dispatch_async • If you are brave and want a quick compile #undef dispatch_retain #define dispatch_retain wjhDispatchRetain #undef dispatch_release #define dispatch_release wjhDispatchRelease 

dispatch_async • With macros... - (void)doSomethingThenInvokeBlock:(void(^)(void))block onQueue:(dispatch_queue_t)queue { wjhDispatchRetain(queue); dispatch_async(dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // Do Something... dispatch_async(queue, block); wjhDispatchRelease(queue); }); } 

dispatch_async • Do Not Block the Main Thread!!! • GCD easily allows all work to be off main thread • Execute code in main thread (UI) dispatch_async(queue, ^{ // Do Something dispatch_async(dispatch_get_main_queue(), ^{ // Running on main thread. Do UI stuff here. }); }); 

dispatch_async • Difference between these? dispatch_async(queue, ^{ // Do Something }); // Small window for other stuff to be put on queue dispatch_async(queue, ^{ // Do Something Else }); dispatch_async(queue, ^{ // Do Something // Next block not put on queue until this one executes dispatch_async(queue, ^{ // Do Something Else }); }); 

dispatch_sync • Dispatch block and wait for it to complete before returning dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // Do Something }); // Do not get here until the above block has run to completion • Can be useful as general synchronization primitive • Pair with async for read/write operations 

dispatch_sync • Can deadlock dispatch_sync(queue, ^{ // Do Something dispatch_sync(queue, ^{ // Causes deadlock. }); }); • Be cautious about using *sync API • Can run on calling thread 

Suspend / Resume • All dispatch objects (including queues) can be suspended and resumed • Immediately after running block(s) 

Retargeting Queues • Can change target of queue (barrier) • All dequeue operations run in context of target queue • “Cut in line” pattern lowPriorityQueue = dispatch_queue_create( "com.foo.low", DISPATCH_QUEUE_SERIAL); highPriorityQueue = dispatch_queue_create( "com.foo.high", DISPATCH_QUEUE_SERIAL); dispatch_set_target_queue(lowPriorityQueue, highPriorityQueue); 

Cut in Line - (void)async:(void(^)(void))block { dispatch_async(lowPriorityQueue, block); } - (void)asyncHighPriority:(void(^)(void))block { dispatch_suspend(lowPriorityQueue); dispatch_async(highPriorityQueue, ^{ block(); dispatch_resume(lowPriorityQueue); }); } • What if did same without retargeting? 

Change Priority • Change queue to high priority dispatch_set_target_queue( queue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)); • Happens after current queue drains 

Barrier Blocks • For concurrent queues (not global queues) • Waits for all enqueued blocks to execute • Only block executing on concurrent queue • Synchronizing concurrent operations • Reader/Writer locks 

Reader/Writer Locks - (void)withReadAccess:(void(^)(void))block { dispatch_sync(queue_, block); } - (void)withWriteAccess:(void(^)(void))block { dispatch_barrier_async(queue_, block); } • Multiple threads executing read block • One thread executing write block • Make concurrent queue act like serial queue • Other way to make concurrent queue serial? 

Synchronize Multiple Blocks • dispatch_barrier • dispatch_apply void dispatch_apply( size_t iterations, dispatch_queue_t queue, void (^block)(size_t)); • dispatch_group • Coordinate multiple queues 

dispatch_io • Use dispatch_io for any I/O operations • Do not “block” in a block execution on a queue 

NSOperationQueue • Implemented in terms of GCD • Higher level of abstraction (better?) • Fixed width concurrent queues • Implement easily with semaphores • Simulate with N serial queues (danger) • Operation dependencies