grand-central-dispatch

I'm using GCD to do some background loading from the internet. This works great except for a little flaw. In my app I have 3 tabs and when clicking on any tab the GCD starts to do the background loading for the appropriate tab. If the user decides to go from the first tab to the second tab (when the GCD has started downloaded data for the first tab) and then returns to the first tab again. GCD will start another background thread (even though the first background thread hasn't finished downloaded the data yet). So is there a way to check if a background thread is currently running? So that it

I have code that looks something like this: [SVProgressHUD show]; [imageGenerator generateCGImagesAsynchronouslyForTimes:times completionHandler:^(CMTime requestedTime, ...) { dispatch_group_async(queueGroup, queue, ^{ // Do stuff }); }]; dispatch_group_wait(queueGroup, DISPATCH_TIME_FOREVER); [SVProgressHUD dismiss]; Basically, display a loading animation HUD and start generating image thumbnails from an asset, then once it's done hide the HUD. I'm using a dispatch group since i want to make sure all the thumbnails are generated before i hide the HUD. But when i run it, the HUD gets dismissed

At the top of my UITableViewController is the following: let queue = DispatchQueue(label: "background") When a task is deleted, the following executes: self.queue.async { autoreleasepool { let realm = try! Realm() realm.beginWrite() realm.delete(task) do { try realm.commitWrite() } catch let error { self.presentError() } } } And then I receive the error terminating with uncaught exception of type realm::IncorrectThreadException: Realm accessed from incorrect thread. How could I fix this? Samantha It seems like the write is happening on a different thread than the object was originally accessed

I have an image loader class which provided with NSURL loads and image from the web and executes completion block. Code is actually quite simple - (void)downloadImageWithURL:(NSString *)URLString completion:(BELoadImageCompletionBlock)completion { dispatch_async(_queue, ^{ // dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{ UIImage *image = nil; NSURL *URL = [NSURL URLWithString:URLString]; if (URL) { image = [UIImage imageWithData:[NSData dataWithContentsOfURL:URL]]; } dispatch_async(dispatch_get_main_queue(), ^{ completion(image, URLString); }); }); } When I

My program is a server which handles incoming requests. Each valid request is wrapped in NSOperation and passed to a normal NSOperationQueue . Each NSOpearation processes its request. In some cases, there is contention at a NSDictionary which I use dispatch_queue (concurrent queue), dispatch_barrier_async (when set value) and dispatch_sync (when get value) to make this NSDictionary thread-safe. I test my program with 100 requests concurrently then the process freezes sometimes. I kill the process with SIGSEGV to see crash log. Most of the threads stuck at dispatch_sync of this queue. And there

Is this the right way? // convert const void *buffer = NULL; size_t size = 0; dispatch_data_t new_data_file = dispatch_data_create_map(data, &buffer, &size); if(new_data_file){ /* to avoid warning really - since dispatch_data_create_map demands we care about the return arg */} NSData *nsdata = [[NSData alloc] initWithBytes:buffer length:size]; // use the nsdata... code removed for general purpose // clean up [nsdata release]; free(buffer); // warning: passing const void * to parameter of type void * It is working fine. My main concern is memory leaks. Leaking data buffers is not fun. So is the