GCD: asynchronously wait for condition - ios

Question

In my iOS app, I would like to wait for a condition to become true before updating the UI.
I am doing like this:
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
while (!condition) NSLog("waiting for the condition");
dispatch_sync(dispatch_get_main_queue, ^{
//update the UI here
});
});
The code above works just fine but I would like to ask if using the while loop to do the waiting job is good or not, and if there is any better way.
Thanks!
---Update
The condition is actually a combination of 4 BOOL variables. Each variable associates with a request for content from the server. I'm using AFNetworking framework. In the completion block of each of the 4 requests, I will set the associated BOOL variable to YES.
So, the actual while loop is like this:
while (!([MyRequest request1].isFinished && [MyRequest request2].isFinished && [MyRequest request3].isFinished && [MyRequest request4].isFinished)) NSLog("waiting for the condition");

Answer 1

In the revised question, it sounds like you have four AFNetworking operations that you want to be dependent upon. That's far easier. You might just add a new operation, and make it dependent upon the other four operations:
NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
// update UI
}];
}];
[operation addDependency:requestOneOperation];
[operation addDependency:requestTwoOperation];
[operation addDependency:requestThreeOperation];
[operation addDependency:requestFourOperation];
[queue addOperation:operation];
The addDependency mechanism essentially does KVO of isFinished of each of those other four operations for you. It's one of the joys of using an NSOperation-based framework like AFNetworking. This sort of dependency is really easy to do.
Original answer:
If you had to do this, you might use a semaphore instead, e.g., you'd create a semaphore:
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
You'd have your async block wait for that:
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
dispatch_semaphore_wait(semaphore);
dispatch_sync(dispatch_get_main_queue, ^{
//update the UI here
});
});
And when the condition is satisfied, the code that would have otherwise set this condition flag would, instead:
dispatch_semaphore_signal(semaphore);
Having said that, I'd rather not see a queue blocked (even a concurrent global queue) like this unless absolutely necessary. If that other code could issue the semaphore signal, I'm not sure why it couldn't just initiate the UI update itself. If I did use this semaphore technique, at the very least I'd have this waiting process taking place on a queue of my own creation, not a global queue.
Another approach which you can use in many situations, and which I'd probably prefer, is to employ key value observing:
For example, I could observe the changing of they someProperty property of an object called obj like so:
[obj addObserver:self forKeyPath:#"someProperty" options:NSKeyValueObservingOptionNew context:NULL];
I would then implement observeValueForKeyPath:
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
if ([keyPath isEqualToString:#"someProperty"])
{
NSLog(#"update UI here");
}
}
Whenever the someProperty property of my obj object is updated, my observeValueForKeyPath method would be called.
FYI, I'd also make sure that before this object gets released, I'd remove the observer of obj:
[obj removeObserver:self forKeyPath:#"someProperty"];
Clearly, this assumes that someProperty is Key Value Coding Compliant. But if it is, this is a great technique.

Answer 2

While the general pattern here is correct (Apple refers to it as "call callback"), the while(!condition) bit is also known as a "spin lock", and is definitely not the best way to wait for a condition. Consider using NSTimer or NSRunLoop instead.