所以我将一系列图像发布到我的服务器上。我想使用GCD异步发布数组，但我也想让这个发生同步的方法，以便我可以传回一个响应对象。但是，dispatch_group_wait方法似乎立即返回（而不是等待我的块完成）。这是一个问题，因为我在块中使用了块吗？
NSArray *keys = [images allKeys];
__block NSMutableDictionary *responses = [NSMutableDictionary dictionaryWithCapacity:[images count]];
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (int i = 0; i < [keys count]; i++) {
__block NSString *key = [keys objectAtIndex:i];
dispatch_group_async(group, queue, ^{
[self postImage:[images objectForKey:key] completionHandler:^(ServerResponse *response){
@synchronized(responses){
if ([response succeeded]) {
NSString *value = [[response data] objectForKey:@"image_token"];
[responses setObject:value forKey:key];
NSLog(@"inside success %@",responses);
} else {
NSString *error = response.displayableError;
if (!error) {
error = @"Sorry something went wrong, please try again later.";
}
[responses setObject:error forKey:@"error"];
[responses setObject:response forKey:@"response"];
}
}
}];
});
}
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_release(group);
我想等待所有[self postImage]方法从服务器回调并修改响应字典。
答案 0 :(得分：9)
Jonathan的信号量示例是针对目标的。但是，我提到使用条件变量作为替代，所以我想我至少会发布一个例子。一般来说，CV可以用来等待除N工人以外的更一般的条件。
请注意，条件变量有它们的位置（虽然不一定在这里），通常最好在需要锁定以改变共享状态时，其他线程可以等待特定条件。
NSUInteger numKeys = [keys count];
NSConditionLock *conditionLock = [[NSConditionLock alloc] initWithCondition:numKeys];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (NSUInteger i = 0; i < numKeys; i++) {
__block NSString *key = [keys objectAtIndex:i];
dispatch_async(queue, ^{
[self postImage:[images objectForKey:key] completionHandler:^(ServerResponse *response){
// Basically, nothing more than a obtaining a lock
// Use this as your synchronization primitive to serialize access
// to the condition variable and also can double as primitive to replace
// @synchronize -- if you feel that is still necessary
[conditionLock lock];
...;
// When unlocking, decrement the condition counter
[conditionLock unlockWithCondition:[conditionLock condition]-1];
}];
});
}
// This call will get the lock when the condition variable is equal to 0
[conditionLock lockWhenCondition:0];
// You have mutex access to the shared stuff... but you are the only one
// running, so can just immediately release...
[conditionLock unlock];
答案 1 :(得分：7)
在没有看到-postImage:completionHandler:的代码的情况下，很难说事情的安排在哪里，但我假设他们打电话给iOS提供的东西。如果是这样，则块内的处理程序块将异步调度到全局队列，然后iOS提供的函数或方法立即返回。就你的派遣小组而言，工作几乎是立即完成的。
没有简单的方法可以让小组等待在dispatch_group_wait()来电之前尚未安排的工作。但是，我们可以添加一个名为信号量的低级thingamajigger，它可以确保我们的操作以正确的顺序完成，并将其安排在内部（异步）块的范围之外。
NSUInteger numKeys = [keys count];
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (NSUInteger i = 0; i < numKeys; i++) {
__block NSString *key = [keys objectAtIndex:i];
dispatch_group_async(group, queue, ^{
// We create a semaphore for each block here. More on that in a moment.
// The initial count of the semaphore is 1, meaning that a signal must happen
// before a wait will return.
dispatch_semaphore_t sem = dispatch_semaphore_create(1);
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
[self postImage:[images objectForKey:key] completionHandler:^(ServerResponse *response){
...
// This instructs one caller (i.e. the outer block) waiting on this semaphore to resume.
dispatch_semaphore_signal(sem);
}];
// This instructs the block to wait until signalled (i.e. at the end of the inner block.)
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
// Done with the semaphore. Nothing special here.
dispatch_release(sem);
});
}
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
// Now all the tasks should have completed.
dispatch_release(group);
虽然存在问题。信号量是内核资源。如果我们有100个任务要执行，但内核只能提供99个信号量怎么办？糟糕的事情发生了。我们可以重建代码只使用一个信号量，虽然等待它会显得有些不稳定。顺便说一下，这样做实际上完全消除了调度组，所以我们基本上用信号量替换了组。我们来看看吧！
NSUInteger numKeys = [keys count];
// set the count of the semaphore to the number of times it must be signalled before
// being exhausted. Up to `numKeys` waits will actually wait for signals this way.
// Additional waits will return immediately.
dispatch_semaphore_t sem = dispatch_semaphore_create(numKeys);
for (int i = 0; i < numKeys; i++) {
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
}
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (NSUInteger i = 0; i < numKeys; i++) {
__block NSString *key = [keys objectAtIndex:i];
dispatch_async(queue, ^{
[self postImage:[images objectForKey:key] completionHandler:^(ServerResponse *response){
...;
// This decrements the semaphore's count by one. The calling code will be
// woken up by this, and will then wait again until no blocks remain to wait for.
dispatch_semaphore_signal(sem);
}];
});
}
// At this point, all the work is running (or could have already completed, who knows?).
// We don't want this function to continue running until we know all of the blocks
// have run, so we wait on our semaphore a number of times equalling the number
// of signals we expect to get. If all the blocks have run to completion before we've
// waited for all of them, the additional waits will return immediately.
for (int i = 0; i < numKeys; i++) {
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
}
// Now all the tasks should have completed.
dispatch_release(sem);
答案 2 :(得分：3)
如上所述，dispatch_group_wait()没有等待，因为postImage:completionHandler:调用似乎是异步的。如果你真的需要这段代码同步执行，那么信号量或锁似乎是一个合适的解决方案。
但是，如果您只想收集一个字典的所有响应以进行处理，我相信最合适的解决方案是使用GCD。并使用调度队列来管理可变字典;在我看到的大多数文档中，这似乎是苹果首选的解决方案。
解决方案的关键在于将可变字典的所有权实质上转移到单个队列，然后只从该队列中修改它。我所指的“所有权”不是内存管理意义上的对象所有权，而是修改意义权的所有权。
我会考虑这样做：
NSArray *keys = [images allKeys];
// We will not be reasigning the 'responses' pointer just sending messages to the NSMutableDictionary object __block is not needed.
NSMutableDictionary *responses = [NSMutableDictionary dictionaryWithCapacity:[images count]];
// Create a queue to handle messages to the responses dictionary since mutables are not thread safe.
// Consider this thread the owner of the dictionary.
dispatch_queue_t responsesCallbackQueue = dispatch_queue_create("com.mydomain.queue", DISPATCH_QUEUE_SERIAL);
for (NSString *key in keys) {
// This async call may not be needed since postImage:completionHandler: seems to be an async call itself.
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[self postImage:[images objectForKey:key] completionHandler:^(ServerResponse *response){
dispatch_async(responsesCallbackQueue, ^{
[responses setObject:response forKey:key];
// Perhaps log success for individual requests.
if (responses.count == keys.count){
NSLog(@"All requests have completed");
// All responses are available to you here.
// You can now either transfer back 'ownership' of the dictionary.
dispatch_async(dispatch_get_main_queue(), ^{
[self requestsHaveFinished:responses];
});
}
});
}];
});
}