Image download was not in proper order - objective-c

Question

NSOperationQueue *queue = [NSOperationQueue new];
NSInvocationOperation *operation;
for(int k=0; k<[imageArray count]; k++)
{
operation = [[NSInvocationOperation alloc] initWithTarget:self selector:#selector(loadData:) object:[imageArray objectAtIndex:k]];
[queue addOperation:operation];
[operation release];
}
using above code I called the method loadData to download some images.
-(void)loadData:(NSString*)newImage
{
[CATransaction begin];
[CATransaction setDisableActions:YES];
NSData * imageData = [[NSData alloc] initWithContentsOfURL: [NSURL URLWithString:newImage]];
NSString* appSuppPath = [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSString* foofile = [appSuppPath stringByAppendingPathComponent:#"/PSDB"];
NSString * str =[NSString stringWithFormat:#"%#/%d.jpeg",foofile,x];
x++;
[imageData writeToFile:str atomically:YES];
[CATransaction commit];
}
The images were downloaded and saving. The problem was the low sized images were downloaded quickly. For example if the 6th image is the low sized image, then It downloaded first and saved as 1.jpeg. how can I make it as order.

Answer 1

From NSOperationQueue doc
An operation queue executes its queued operation objects based on their priority and readiness. If all of the queued operation objects have the same priority and are ready to execute when they are put in the queue—that is, their isReady method returns YES—they are executed in the order in which they were submitted to the queue. For a queue whose maximum number of concurrent operations is set to 1, this equates to a serial queue. However, you should never rely on the serial execution of operation objects. Changes in the readiness of an operation can change the resulting execution order.
if setMaxConcurrentOperationCount doesnt help, try to play with -isReady method inside your custom NSInvocationOperation

Answer 2

When using concurrent queues, you have no assurances regarding the order that they complete. But, you really should not care. Let them complete in the most efficient manner possible.
I would have thought, though, that you want the filename to correspond to the index k of the URL. So, I'd suggest you change the download process to just use k as you initiate the request, and retire the use of x, e.g.:
NSOperationQueue *queue = [NSOperationQueue new];
queue.maxConcurrentOperationCount = 5; // limit number of concurrent requests to some reasonable number
NSString* appSuppPath = [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSString* foofile = [appSuppPath stringByAppendingPathComponent:#"PSDB"];
for (int k = 0; k < [imageArray count]; k++)
{
[queue addOperationWithBlock:^{
NSData * imageData = [[NSData alloc] initWithContentsOfURL: [NSURL URLWithString:[imageArray objectAtIndex:k]]];
if (imageData)
{
NSString * str = [NSString stringWithFormat:#"%#/%d.jpeg", foofile, k];
[imageData writeToFile:str atomically:YES];
}
}];
}
This eliminates the asynchronous updating of your counter, x, eliminating the file numbering problem. (This also solves a thread-safety problem in your original code: What if two downloads completed at the same time, thus both using the same value of x?) This also ensures that your files are named properly.
Now, if you really want them to complete sequentially for other reasons, you could do this in a serial queue (e.g. maxConcurrentOperationCount = 1), but there is a significant performance penalty for doing that. It's much better to design your architecture so that the completion order is not important. E.g. if you just need to know when they're done, add a completion operation dependent upon the others finishing.
Certainly, the code change above solves a tactical problem, but if there are other reasons why you think you need them to finish in the order that you queued them, let us know, because there are probably solutions that won't necessitate that and let you enjoy the performance improvement of concurrent downloads.