grand-central-dispatch

I try to understand GCD and wrote this code to find out run priority: override func viewDidLoad() { super.viewDidLoad() fetchImage() print(1) dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) { print(2) } dispatch_async(dispatch_get_main_queue()) { print(3) } dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0)) { print(5) } } I got next result in the console: 1 2 5 3 So the question is: Part 1 : Why 3 is after 5 (main_queue has highest priority?) Part 2 : And why 2 is higher that 3 and 5 as well? Thank you guys! Bear in mind: this is multi-threading, on

Looking at some Apple code sample, I found this: func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) { // wait() is used to drop new notifications if old ones are still processing, to avoid queueing up a bunch of stale data. if metadataObjectsOverlayLayersDrawingSemaphore.wait(timeout: .now()) == .success { DispatchQueue.main.async { // Some processing... self.metadataObjectsOverlayLayersDrawingSemaphore.signal() } } } Context of the code : This is the delegate method when using video capture to detect a QR

dispatch_once call causes crash (in simulator) after I've converted my project to ARC. My original problem was that I've got EXC_BAD_ACCESS (in objc_retain call) crash in one of my singleton object's + (SingletonClass)shared { ... dispatch_once(..., ^{}); ... } method exactly one line before the dispatch_once call. Based on loggings, and breakpoints my code have not run into the dispatch_once call's block. I didn't know the reason, so I've just commented out the dispatch_once call. My app haven't crashed without that call. After that I've tried to put dispatch_once in a method that my app

What is the real effect of calling performSelectorInBackground:... from a method that is running in the background? I want it to run asynchronously For example: - (void) _imageBufferWasUpdated{ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; //do something here if(shouldContinue){ [self performSelectorInBackground:@selector(_loop) withObject:nil]; } [pool release]; } _imageBufferWasUpdated will run in the background and I want to call _loop method asynchronously (in the background also so _imageBufferWasUpdated will finish soon, probably before _loop ends). Is this correct? Is

I want to have a for loop with dispatch_after statements in them. Problem is that the dispatch_after calls don't seem to go in line with the for loop. In other words, I want it to only start the next iteration of the for loop after the statements in the dispatch_after block have executed. How would I do this? Use Case I want to present words on screen. Traditionally I show one word per second. But depending on the word length, I now want to show longer words for slightly longer, and shorter words for slightly less time. I want to present a word, wait a little while (depending on how long the

When I do the following: dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, NULL), ^{ create NSURLRequest; create NSURLConnectionDelegate; create NSURLConnection; start NSURLConnection; }); The delegate's methods never get called. But when I do dispatch_async(dispatch_get_main_queue(), ^{ create NSURLRequest; create NSURLConnectionDelegate; create NSURLConnection; start NSURLConnection; }); They do get called. Why? UPD http://developer.apple.com/library/ios/#qa/qa1712/_index.html Now I do create NSURLConnection; start NSURLConnection; on the main thread. In the first case,

According to the WWDC 2012 video, "Core Data Best Practices", dispatch_sync should be used to run some kind of callback in performBlock of context, which is created as a type of NSPrivateQueueConcurrencyType . Why is that? Can I use dispatch_async(dispatch_get_main_queue(), 0) ... to call some UI-related callbacks in private queue's context's performBlock ? No. NSPrivateQueueConcurrencyType manages it's own internal queue, and does not enjoy you trying to leave one of it's threads to do what you want to do (in fact, I believe it throws exceptions when this type of behavior occurs). There's a