一次从几个pffile异步下载数据 [英] downloading data from several pffile's at once asynchronosly
问题描述
如果我有一个Message对象的数组，每个对象都有一个包含数据的PFile，是否可以通过异步排队每个消息来下载数据，如下所示:
If I have an array of Message objects, each with a PFile containing data, is it possible to download the data for every single message by queuing them up asynchronously like so:
for (int i = 0; i < _downloadedMessages.count; i++) {
PFObject *tempMessage = (PFObject *)[_downloadedMessages objectAtIndex:i];
[[tempMessage objectForKey:@"audio"] getDataInBackgroundWithBlock:^(NSData *data, NSError *error) {
[self persistNewMessageWithData:data];
}];
}
这似乎导致我的应用挂起，即使此操作应在后台执行...
This seems to cause my app to hang, even though this should be done in the background...
使用以下解决方案:
NSMutableArray* Objects = ...
[self forEachPFFileInArray:Objects retrieveDataWithCompletion:^BOOL(NSData* data, NSError*error){
if (data) {
PFObject *tempObj = (PFObject *)Object[someIndex...];
[self persistNewMessageWithData:data andOtherInformationFromObject:tempObj];
return YES;
}
else {
NSLog(@"Error: %@", error);
return NO; // stop iteration, optionally continue anyway
}
} completion:^(id result){
NSLog(@"Loop finished with result: %@", result);
}];
推荐答案
您可能会遇到的问题是，对于大量同时运行的异步请求，系统可能会由于内存而阻塞压力以及网络停顿或其他资源耗尽(包括CPU)的访问.
What you are possibly experiencing is, that for a large numbers of asynchronous requests which run concurrently, the system can choke due to memory pressure and due to network stalls or other accesses of resources that get exhausted (including CPU).
您可以使用带有分配"工具的仪器来验证内存压力的发生.
You can verify the occurrence of memory pressure using Instruments with the "Allocations" tool.
内部(即在Parse库和系统中)可能存在一个变量集，该变量集设置了可以同时运行的最大网络请求数.但是，在您的for循环中，您将所有请求放入队列.
Internally (that is, in the Parse library and the system) there might be a variable set which sets the maximum number of network requests which can run concurrently. Nonetheless, in your for loop you enqueue ALL requests.
在您的情况下，取决于请求排队的含义，此过程并非完全免费.这可能会占用大量内存.在最坏的情况下，网络请求将被系统排队，但基础网络堆栈仅执行并发请求的最大数量.其他已入队，但待处理请求挂在那里并等待执行，而它们的网络超时已在运行.由于这些事件的超时已过期，因此可能会导致这些事件的取消.
Depending of what enqueuing a request means in your case, this procedure isn't free at all. It may cost a significant amount of memory. In the worst case, the network request will be enqueued by the system, but the underlying network stack executes only a maximum number of concurrent requests. The other enqueued but pending requests hang there and wait for execution, while their network timeout is already running. This may lead to cancellation of pending events, since their timeout expired.
嗯，解决上述问题最明显的方法就是简单地将所有任务序列化.也就是说，它仅在前一个异步任务完成时才启动下一个异步任务(包括完成处理程序中的代码).可以使用一种异步模式(我将其命名为异步循环")来完成此操作:
Well, the most obvious approach solving the above issues would be one which simply serializes all tasks. That is, it only starts the next asynchronous task when the previous has been finished (including the code in your completion handler). One can accomplish this using an asynchronous pattern which I name "asynchronous loop":
异步循环"是异步的，因此具有完成处理程序，该处理程序在所有迭代完成后会被调用.
The "asynchronous loop" is asynchronous, and thus has a completion handler, which gets called when all iterations are finished.
typedef void (^loop_completion_handler_t)(id result);
typedef BOOL (^task_completion_t)(PFObject* object, NSData* data, NSError* error);
- (void) forEachObjectInArray:(NSMutableArray*) array
retrieveDataWithCompletion:(task_completion_t)taskCompletionHandler
completion:(loop_completion_handler_t)completionHandler
{
// first, check termination condition:
if ([array count] == 0) {
if (completionHandler) {
completionHandler(@"Finished");
}
return;
}
// handle current item:
PFObject* object = array[0];
[array removeObjectAtIndex:0];
PFFile* file = [object objectForKey:@"audio"];
if (file==nil) {
if (taskCompletionHandler) {
NSDictionary* userInfo = @{NSLocalizedFailureReasonErrorKey: @"file object is nil"}
NSError* error = [[NSError alloc] initWithDomain:@"RetrieveObject"
code:-1
userInfo:userInfo];
if (taskCompletionHandler(object, nil, error)) {
// dispatch asynchronously, thus invoking itself is not a recursion
dispatch_async(dispatch_get_global(0,0), ^{
[self forEachObjectInArray:array
retrieveDataWithCompletion:taskCompletionHandler
completionHandler:completionHandler];
});
}
else {
if (completionHandler) {
completionHandler(@"Interuppted");
}
}
}
}
else {
[file getDataInBackgroundWithBlock:^(NSData *data, NSError *error) {
BOOL doContinue = YES;
if (taskCompletionHandler) {
doContinue = taskCompletionHandler(object, data, error);
}
if (doContinue) {
// invoke itself (note this is not a recursion")
[self forEachObjectInArray:array
retrieveDataWithCompletion:taskCompletionHandler
completionHandler:completionHandler];
}
else {
if (completionHandler) {
completionHandler(@"Interuppted");
}
}
}];
}
}
用法:
// Create a mutable array
NSMutableArray* objects = [_downloadedMessages mutableCopy];
[self forEachObjectInArray:objects
retrieveDataWithCompletion:^BOOL(PFObject* object, NSData* data, NSError* error){
if (error == nil) {
[self persistNewMessageWithData:data andOtherInformationFromObject:object];
return YES;
}
else {
NSLog(@"Error %@\nfor PFObject %@ with data: %@", error, object, data);
return NO; // stop iteration, optionally continue anyway
}
} completion:^(id result){
NSLog(@"Loop finished with result: %@", result);
}];
这篇关于一次从几个pffile异步下载数据的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
