GCD - executing methods on order after finishing others - iphone

Question

I have a class that I call several times with different data.
That class, calls a web-service, parse it's response to NSDictionary, and save the data on Core Data.
The call of the web service and the saving in core data are done in different threads, using core data queues, so that the UI keeps responsive.
Class:
- (void)refreshDataFromWebService:(NSString *)webserviceWSDL
{
dispatch_queue_t receiveActivities = dispatch_queue_create("com.myApp.ws.wsdlMethod", NULL);
dispatch_async(receiveData, ^(void)
{
//call web service
//...
//parse received data to NSDictionary
//...
});
dispatch_release(receiveData);
}
//some work
//the class that works with the WS, calls a method on it's delegate, and the saveData is called.
- (void)saveData
{
dispatch_queue_t request_queue = dispatch_queue_create("com.myApp.insertDataOnCoreData", NULL);
dispatch_async(request_queue, ^{
//save data to CoreData with new Manage Object Context
//...
//...
});
dispatch_release(request_queue);
}
The issue is that I need to call this Class about 15 times, and in some order.
What is the best way to do it?
Should I call:
[SomeClass refreshDataFromWebService:method_1];
[SomeClass refreshDataFromWebService:method_2];
[SomeClass refreshDataFromWebService:method_3];
[SomeClass refreshDataFromWebService:method_4];
or should I do a different way?
The goal is that method_2 is only called after method_1 is finish saving on CoreData, due to relationships.
Thanks for you precious help,
Rui Lopes

Answer 1

Your first call to receive data and then save data the will not work in any scenario where it takes longer to receive data than it does to call save the data, which would likely almost always be the case. The save operation needs to be called inside of the receive block at the end. Now for the services to be called one at a time in order you should create an ivar for a serial dispatch queue for the class and use that and only release it in the dealloc method. Another option is to use NSOperations with a queue that has max concurrent operations set to 1.

Answer 2

Why don't you simply create a single serial queue for each instance of your class and then serialize the operations against the internal queue? This will ensure that method_2 happens after method_1 (assuming that method_1 was enqueue first, by design) while still allowing all instances of the class to run in parallel with respect to one another. This assumes, of course, that this is your goal - it's hard to tell from the code fragment in question.