grouping multiple method calls into one execution a short time later - ios

Question

I'm writing a custom file system cache component that has an index dictionary that represents important attributes about the files within the folder.
This is for an iOS app, and I'm writing in Objective-C
At various points in the implementation of adding objects / deleting object from the cache, the index dictionary needs to be saved to disk.
In order to stop this operation happening needlessly many times over, for example if objects are added to the cache in a for.. loop, I want to make a system that every time the dictionary is modified, a state is set to ensure that at some point in the future the dictionary will be saved. This should not happen immediately however, in case another change is made quickly, in which case the first 'save' operation should not happen, but another one should be queued up.
In pseudo-code:
//This is the method called by all other parts of the program whenever the dictionary is modified and it needs to be changed
-(void) dispatchSaveIndexDictionary {
//cancel any previous requests to save.
//queue up a save operation some short time later.
}
How I've implemented this:
-(void)saveIndexDictionaryDispatchDelayed
{
NSLog(#"dispatching index save");
[NSObject cancelPreviousPerformRequestsWithTarget:self selector:#selector(saveIndexDictionaryWriteToDisk) object:nil];
//Delay 0 means it gets queued up asap, which means the index dictionary on disk remains in sync whenever possible.
// - This is to solve the case of adding multiple objects in a for... loop
[self performSelector:#selector(saveIndexDictionaryWriteToDisk) withObject:nil afterDelay:0];
}
-(void)saveIndexDictionaryWriteToDisk
{
NSLog(#"Writing cache index to disk : %#", self.cachePath);
[NSKeyedArchiver archiveRootObject:self.indexDictionary
toFile:[OFMFileSystemCache indexDictionaryFullPathWithCachePath:self.cachePath]];
}
Using performSelector:withObject:afterDelay:0
I expected that this would always perform the 'write to disk' method AFTER any of the 'dispatch ' operations, i.e. we could have multiple write operations, if tasks took a long time, but that the 'write' operation would always be the last thing to happen.
I've seen from the logs that this does not always happen, if I do the simple use case of adding 10 files to the cache, then sometimes I get 'dispatching index save' happening and no call afterwards to 'Writing cache index to disk'. I don't really understand how this is possible!
Is there some reason why my implementation isn't a good idea (I guess there must be as it doesn't work very well)?
What do you think is a good secure design for this type of delayed method call, as it's critical that the index remains up to date with the contents of the cache. I.E. write to cache should always happen last, after all modifications have been made.
Thanks.

Answer 1

I've done something similar in my caches in the past. What I end up doing instead of using performSelector:afterDelay: is setup an NSTimer. Something like:
// elsewhere, setup an NSTimer* ivar called saveTimer
-(void) saveToDisk{
saveTimer = nil;
// actually save here
}
-(void)resetSaveTimer{
if(saveTimer) [saveTimer invalidate];
saveTimer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:#selector(saveToDisk) userInfo:nil repeats:NO];
}
-(void)doStuffWithCache{
// do stuff, add stuff, whatever
[self resetSaveTimer];
}
Depending on your threading, you may also want to add #synchronized(yourCacheDictionary){...} for each of the method bodies, just to make sure you're not trying to write to disk while also editing the dictionary, etc.

Answer 2

Following on from adam.wulf, I wanted to post the solution that I have finally settled on.
This uses NSTimer as suggested, because I had found inconsistent behaviours I couldn't explain with the 'NSObject performSelector:afterDelay:' approach.
After trying the timers approach I needed to modify the solution in some important ways.
1 - make sure the timer is dispatched on a queue with a properly set up runloop for timer execution. I'm using an external caching library for some caching operations, and this calls back on queues that are not set up appropriately. The easiest solution for me was to always dispatch the timer call on the main queue.
2 -Dispatch the actual write operation on a dedicated serial queue, so as not to block the main queue (where the timer method will fire as it is dispatched on that queue).
3 - As suggested wrapping the index Dictionary write to disk methods in #synchronized(indexDictionary) { } to ensure the contents are not modified while being written.
#pragma mark - Saving Index Dictionary
-(void)saveIndexDictionaryDispatchDelayed
{
dispatch_async(dispatch_get_main_queue(), ^{
if (_dispatchSaveTimer) {
[_dispatchSaveTimer invalidate];
_dispatchSaveTimer = nil;
}
_dispatchSaveTimer = [NSTimer scheduledTimerWithTimeInterval:0.5
target:self
selector:#selector(saveIndexDictionaryWriteToDisk)
userInfo:nil
repeats:NO];
});
}
-(void)saveIndexDictionaryWriteToDisk
{
dispatch_async(_cacheOperationQueue, ^{
#synchronized (self.indexDictionary) {
_dispatchSaveTimer = nil;
NSLog(#"Writing cache index to disk : %#", self.cachePath);
[NSKeyedArchiver archiveRootObject:self.indexDictionary
toFile:[OFMFileSystemCache indexDictionaryFullPathWithCachePath:self.cachePath]];
}
});
}